@intentius/chant 0.81.0 → 0.82.0

package/dist/cli/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AAMA,OAAO,EAAkB,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAiG9E;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CA2apD;AAujBD;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAuBzE;AAID;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,UAAU,EA8HvC,CAAC;AAiKF;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB5E"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AAMA,OAAO,EAAkB,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAiG9E;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CA2apD;AAyjBD;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAuBzE;AAID;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,UAAU,EA8HvC,CAAC;AAiKF;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB5E"}

package/dist/workspace/lineage-cli.d.ts

@@ -9,12 +9,14 @@
  * project (#2525 rule 4).
  */
 import type { CommandContext } from "../cli/registry.js";
-import { type ManualStep } from "./lineage-lock.js";
+import { type LineageSource, type ManualStep } from "./lineage-lock.js";
 export interface LineageScopeView {
     scope: string;
     kind: "template" | "vendor";
     name?: string;
     template: string;
+    /** Where the files came from, as the lock records it: its `type` and the repository, directory, lexicon or URL. */
+    source: LineageSource;
     ref?: string;
     address: Record<string, unknown> | null;
     files: number;
@@ -22,6 +24,8 @@ export interface LineageScopeView {
     missing: string[];
     manualSteps: ManualStep[];
 }
+/** One line naming a scope's source kind and where it points (#2647). */
+export declare function describeSource(source: LineageSource): string;
 /** The lock as `--json` prints it: one view per scope, with its state in the tree. */
 export declare function lineageView(root: string): {
     lock: string;

package/dist/workspace/lineage-cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lineage-cli.d.ts","sourceRoot":"","sources":["../../src/workspace/lineage-cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAA6E,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAI5H,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,gBAAgB,EAAE,CAAA;CAAE,GAAG,IAAI,CAmB7F;AAED,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAmC9E"}
+{"version":3,"file":"lineage-cli.d.ts","sourceRoot":"","sources":["../../src/workspace/lineage-cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAA6E,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIhJ,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,mHAAmH;IACnH,MAAM,EAAE,aAAa,CAAC;IACtB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAa5D;AAED,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,gBAAgB,EAAE,CAAA;CAAE,GAAG,IAAI,CAoB7F;AAED,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAoC9E"}

package/dist/workspace/lineage-init.d.ts

@@ -4,9 +4,14 @@
  * with one lineage, scope `"."`, so a project made from a template can be
  * upgraded later without first running adopt-lineage.
  *
- * `--from` fetches with `git`: the one network step, listed in the egress
- * catalogue (`test/egress-catalogue.ts`). The commit and the tree of the
- * chosen directory become the content address.
+ * `--from <repo>@<ref>` fetches with `git`: the one network step, listed in
+ * the egress catalogue (`test/egress-catalogue.ts`). The commit and the tree
+ * of the chosen directory become the content address.
+ *
+ * `--from <dir>[#<member>]` copies a template directory already on disk
+ * (#2647), for a host that carries the template as plain files with no
+ * `.git` and no way to reach its repository. It reaches no network, and the
+ * digest of the copied files is the whole content address.
  *
  * Plain `chant init` without `--template` writes no lock. That keeps the
  * output of an existing command unchanged (#2525 rule 2), and this module
@@ -59,7 +64,40 @@ export declare function readTemplateTree(scratch: string, commit: string, member
  * never copied: it describes the template's lineage, not the new project's.
  */
 export declare function fetchTemplate(spec: TemplateSpec): FetchedTemplate;
+export interface DirTemplateSpec {
+    kind: "dir";
+    /** The directory as written, without `#<member>`. */
+    path: string;
+    /** The directory, absolute. */
+    abs: string;
+    /** The directory inside it to instantiate (`#<member>`). */
+    member?: string;
+}
+/**
+ * Parse `<path>[#<member>]` when `<path>` is an existing directory, or return
+ * null for the git form. A spec without `@` that names no directory is
+ * refused here, since it cannot be a `<repo>@<ref>` either. A directory whose
+ * name happens to parse as `<repo>@<ref>` is a directory: what is on disk wins.
+ */
+export declare function parseDirSpec(spec: string, cwd?: string): DirTemplateSpec | null;
+/** The template's directory as `#<member>` names it, relative to its root, for messages. */
+export declare function dirLabel(path: string, member?: string): string;
+/**
+ * Read the files of a template directory on disk, the way
+ * {@link readTemplateTree} reads a commit: symbolic links, submodules and the
+ * template's own lineage lock are skipped with the reason, and so is
+ * `node_modules`. Inside a git checkout the files are the ones git would
+ * commit, tracked or untracked but not ignored. Elsewhere, or when git is not
+ * installed, every file is copied. The executable bit is the owner's.
+ */
+export declare function readTemplateDir(abs: string, member: string | undefined, label: string): Omit<FetchedTemplate, "commit" | "tree">;
+/**
+ * How a directory source is recorded: an absolute path as given, a relative
+ * one re-expressed from the project, so it resolves from the lock's directory.
+ */
+export declare function recordedDirPath(given: string, abs: string, projectDir: string): string;
 export interface InitFromOptions {
+    /** `<repo>@<ref>[#<member>]`, or `<dir>[#<member>]` for a directory on disk (#2647). */
     from: string;
     /** Target directory (defaults to cwd). */
     path?: string;
@@ -72,12 +110,17 @@ export interface InitFromResult {
     createdFiles: string[];
     warnings: string[];
     error?: string;
+    /** The git form's spec. */
     spec?: TemplateSpec;
+    /** The directory form's spec (#2647). */
+    dir?: DirTemplateSpec;
     commit?: string;
+    /** The lineage's `template` id. */
+    template?: string;
     /** The parameter values used, recorded in the lock. */
     parameters?: Record<string, string>;
 }
-/** `chant init --from <repo>@<ref>[#<member>] [path]`. */
+/** `chant init --from <repo>@<ref>[#<member>] [path]`, or `--from <dir>[#<member>]`. */
 export declare function initFromCommand(options: InitFromOptions): Promise<InitFromResult>;
 export interface TemplateLockInput {
     targetDir: string;

package/dist/workspace/lineage-init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lineage-init.d.ts","sourceRoot":"","sources":["../../src/workspace/lineage-init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAuBH,MAAM,WAAW,YAAY;IAC3B,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6GAA6G;IAC7G,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,MAAsB,GAAG,YAAY,CAwCzF;AAID,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC1D,mDAAmD;IACnD,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClD;AAED,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAQvD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,KAAK,EAAE,MAAM,GACZ;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IAAC,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,CAAA;CAAE,CAiCxF;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,eAAe,CAgBjE;AAID,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,yGAAyG;IACzG,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC;AAED,0DAA0D;AAC1D,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAiFvF;AAgCD,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,mHAAmH;IACnH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,GAAG,IAAI,CA0BzE"}
+{"version":3,"file":"lineage-init.d.ts","sourceRoot":"","sources":["../../src/workspace/lineage-init.ts"],"names":[],"mappings":"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"}

package/dist/workspace/lineage-lock.d.ts

@@ -4,8 +4,9 @@
  * The lock records where a project's files came from. It holds one lineage per
  * scope, keyed by the scope's directory relative to the lock's root:
  *
- * - a project made by `chant init --from <repo>@<ref>` or
- *   `chant init --template <name>` has one scope, `"."`;
+ * - a project made by `chant init --from <repo>@<ref>`,
+ *   `chant init --from <dir>` or `chant init --template <name>` has one
+ *   scope, `"."`;
  * - each `chant vendor` target is a scope of kind `vendor` (copied, no
  *   parameters), which replaces its entry in `vendor.json` (ws-038).
  *
@@ -44,6 +45,10 @@ declare const SourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     repo: z.ZodString;
     url: z.ZodString;
     path: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"dir">;
+    path: z.ZodString;
+    member: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"lexicon">;
     lexicon: z.ZodString;
@@ -90,6 +95,10 @@ declare const LineageSchema: z.ZodObject<{
         repo: z.ZodString;
         url: z.ZodString;
         path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"dir">;
+        path: z.ZodString;
+        member: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"lexicon">;
         lexicon: z.ZodString;
@@ -148,6 +157,10 @@ declare const LockSchema: z.ZodObject<{
             repo: z.ZodString;
             url: z.ZodString;
             path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"dir">;
+            path: z.ZodString;
+            member: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>, z.ZodObject<{
             type: z.ZodLiteral<"lexicon">;
             lexicon: z.ZodString;

package/dist/workspace/lineage-lock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lineage-lock.d.ts","sourceRoot":"","sources":["../../src/workspace/lineage-lock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAKH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAkC,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvF,yEAAyE;AACzE,eAAO,MAAM,SAAS,+BAA+B,CAAC;AAEtD,4EAA4E;AAC5E,eAAO,MAAM,YAAY,IAAI,CAAC;AAM9B;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,yCAA0C,CAAC;AACpE,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAYtD,iDAAiD;AACjD,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;4BAQhB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAoBzD;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,uFAAwF,CAAC;AACzH,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpE,QAAA,MAAM,gBAAgB;;;;;;;;;kBAOX,CAAC;AACZ,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmBR,CAAC;AACZ,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKL,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAIrD,0CAA0C;AAC1C,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAEtD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAShE;AAID,6FAA6F;AAC7F,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO5C;AAID,qBAAa,SAAU,SAAQ,KAAK;IACzB,IAAI,SAAe;CAC7B;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,wBAAgB,SAAS,IAAI,WAAW,CAEvC;AAED,+EAA+E;AAC/E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAIzD;AAED,sGAAsG;AACtG,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAqBnD;AAyBD,4CAA4C;AAC5C,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAEpD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAK/D;AAID;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,aAAa,GAAG;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAI/G;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,CAO7D;AAED,kHAAkH;AAClH,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAOlG;AAID,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,sFAAsF;IACtF,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,4DAA4D;IAC5D,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,wEAAwE;AACxE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,WAAW,CAetF;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG,IAAI,CAoBjH"}
+{"version":3,"file":"lineage-lock.d.ts","sourceRoot":"","sources":["../../src/workspace/lineage-lock.ts"],"names":[],"mappings":"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"}

package/dist/workspace/lineage-upgrade-cli.d.ts

@@ -1,5 +1,5 @@
 /**
- * `chant workspace upgrade [<scope>] [--to <ref>] [--allow-code] [--dry-run]
+ * `chant workspace upgrade [<scope>] [--to <ref|dir>] [--allow-code] [--dry-run]
  * [--output <file>] [--json]` (#2550).
  *
  * Stages the upgrade in a worktree (see ./lineage-upgrade.ts), then decides

package/dist/workspace/lineage-upgrade.d.ts

@@ -9,7 +9,8 @@
  * 1. Fetch the target version of the template. For a git source that is one
  *    `git fetch` of the target ref, plus the commit the scope was made from.
  *    This is the command's only network step, catalogued in
- *    `test/egress-catalogue.ts`. A local repository reaches nothing.
+ *    `test/egress-catalogue.ts`. A local repository reaches nothing, and
+ *    neither does a directory source (#2647), which reads `--to <dir>`.
  * 2. Rebuild the merge base offline: each recorded file's content at the base
  *    commit, kept only when it has the hash the lock recorded. A file the
  *    project never edited is its own merge base. Vendor sources keep no
@@ -63,7 +64,12 @@ export interface UpgradeOptions {
     root: string;
     /** The scope to upgrade: `"."` or a vendor scope's directory. */
     scope?: string;
-    /** The target ref (git) or label (vendor). Defaults to the ref the scope is pinned at. */
+    /**
+     * The target ref (git) or label (vendor). Defaults to the ref the scope is
+     * pinned at. For a directory source, the directory holding the new version,
+     * as `<dir>[#<member>]`, resolved from the current directory; the member
+     * defaults to the recorded one.
+     */
     to?: string;
     /** Run migrations whose body is code. */
     allowCode?: boolean;

package/dist/workspace/lineage-upgrade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lineage-upgrade.d.ts","sourceRoot":"","sources":["../../src/workspace/lineage-upgrade.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"lineage-upgrade.d.ts","sourceRoot":"","sources":["../../src/workspace/lineage-upgrade.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.81.0",
+  "version": "0.82.0",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/cli/handlers/init.ts

@@ -54,14 +54,15 @@ export async function runInitLexicon(ctx: CommandContext): Promise<number> {
  * `chant init --from <repo>@<ref>[#<member>] [--param <name>=<value>]... [path]`
  * (#2540, #2627): copy a template repository at a ref, substitute the
  * parameters its `chant.template.json` declares, and record its lineage.
+ * `--from <dir>[#<member>]` copies a template directory on disk instead (#2647).
  * The template brings its own lexicons and configuration, so `--lexicon` and
  * `--template` do not apply.
  */
 async function runInitFrom(ctx: CommandContext): Promise<number> {
   const { args } = ctx;
-  const usage = "Usage: chant init --from <repo>@<ref>[#<member>] [--param <name>=<value>]... [path]";
+  const usage = "Usage: chant init --from <repo>@<ref>[#<member>] | <dir>[#<member>] [--param <name>=<value>]... [path]";
   if (!args.migrateFrom) {
-    console.error(formatError({ message: "--from needs a template: <repo>@<ref>[#<member>]", hint: usage }));
+    console.error(formatError({ message: "--from needs a template: <repo>@<ref>[#<member>] or <dir>[#<member>]", hint: usage }));
     return 1;
   }
   if (args.lexicon || args.template) {
@@ -95,7 +96,10 @@ async function runInitFrom(ctx: CommandContext): Promise<number> {
   console.log(formatSuccess("Created:"));
   for (const file of result.createdFiles) console.log(`  ${file}`);
   console.log("");
-  console.log(`Lineage: ${result.spec!.id} at ${result.spec!.ref} (${result.commit!.slice(0, 12)}), recorded in .chant/workspace.lock.json`);
+  const from = result.spec
+    ? `${result.spec.id} at ${result.spec.ref} (${result.commit!.slice(0, 12)})`
+    : `${result.template} (a directory, recorded by digest only)`;
+  console.log(`Lineage: ${from}, recorded in .chant/workspace.lock.json`);
   const parameters = Object.entries(result.parameters ?? {});
   if (parameters.length > 0) console.log(`Parameters: ${parameters.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ")}`);
   return 0;

package/src/cli/main.ts

@@ -549,7 +549,9 @@ Usage:
 Commands:
   init                  Initialize a new chant project
                         (--from <repo>@<ref>[#<member>] copies a template
-                        repository and records its lineage; --param
+                        repository and records its lineage, and --from
+                        <dir>[#<member>] copies a template directory on
+                        disk; --param
                         <name>=<value> sets a parameter the template's
                         chant.template.json declares, repeatable)
   init lexicon <name>   Scaffold a new lexicon plugin project
@@ -729,7 +731,7 @@ Workspace (level 1, #2524):
                         manual steps. Needs no workspace file
   workspace lineage resolve <path>
                         Close a manual step once the file is merged by hand
-  workspace upgrade [<scope>] [--to <ref>] [--allow-code] [--dry-run] [--output <file>]
+  workspace upgrade [<scope>] [--to <ref|dir>] [--allow-code] [--dry-run] [--output <file>]
                         Bring a lineage scope to a newer template version: fetch
                         it, migrate and merge per file in a worktree, run build,
                         lint and workspace check there, then gate on the digest

package/src/workspace/behold-kinds.test.ts

@@ -1,15 +1,14 @@
 /**
  * behold's two closed member kinds, read through chant's workspace (#2545).
  *
- * `terraform` ships from the terraform lexicon's `./workspace-kinds` subpath,
- * and `choudoufu` from the kinds-only package
- * `@intentius/workspace-kind-choudoufu`. A workspace that pins both lists
- * members of either kind through `chant workspace ls --json`, with the kinds
- * behold gave the same directories, and reading the kinds imports neither
- * package.
+ * Both ship from the terraform lexicon's `./workspace-kinds` subpath, since
+ * a choudoufu estate is a Terraform root the lexicon's choudoufu mode reads.
+ * A workspace that pins the lexicon lists members of either kind through
+ * `chant workspace ls --json`, with the kinds behold gave the same
+ * directories, and reading the kinds never imports the lexicon.
  *
- * The installed packages are the repo's own: their package.json and kinds
- * file are copied as they ship, and every code entry their `exports` name is
+ * The installed package is the repo's own: its package.json and kinds file
+ * are copied as they ship, and every code entry its `exports` names is
  * replaced by a module that leaves a marker file when it is imported.
  */
 
@@ -25,7 +24,6 @@ import { workingTree } from "./tree";
 
 const REPO = join(import.meta.dirname, "..", "..", "..", "..");
 const TERRAFORM = join(REPO, "lexicons", "terraform");
-const CHOUDOUFU = join(REPO, "packages", "workspace-kind-choudoufu");
 const FIXTURES = join(TERRAFORM, "src", "__fixtures__");
 
 const scratch: string[] = [];
@@ -65,7 +63,7 @@ function install(root: string, from: string): string {
 function workspace(): { root: string; installed: string[] } {
   const root = realpathSync(mkdtempSync(join(tmpdir(), "chant-behold-kinds-")));
   scratch.push(root);
-  const installed = [install(root, TERRAFORM), install(root, CHOUDOUFU)];
+  const installed = [install(root, TERRAFORM)];
   // Estates in the shapes behold serves: a stock root, a choudoufu root with
   // the sidecar, one with the live block, and a chant project beside .tf files.
   cpSync(join(FIXTURES, "no-backend"), join(root, "estates", "stock"), { recursive: true });
@@ -82,7 +80,6 @@ function workspace(): { root: string; installed: string[] } {
         schema: 1,
         pins: [
           { package: "@intentius/chant-lexicon-terraform", version: version(TERRAFORM) },
-          { package: "@intentius/workspace-kind-choudoufu", version: version(CHOUDOUFU) },
         ],
         members: [
           { name: "stock", dir: "estates/stock", kind: "terraform" },
@@ -106,7 +103,7 @@ describe("behold's member kinds from their packages (#2545)", () => {
   });
   afterEach(() => vi.restoreAllMocks());
 
-  test("chant workspace ls --json lists terraform and choudoufu members, readable, and imports neither package", async () => {
+  test("chant workspace ls --json lists terraform and choudoufu members, readable, and never imports the lexicon", async () => {
     const { root, installed } = workspace();
     const code = await runWorkspaceLs({ args: parseArgs(["workspace", "ls", root, "--json"]), plugins: [] } as never);
     expect(code).toBe(0);
@@ -126,12 +123,11 @@ describe("behold's member kinds from their packages (#2545)", () => {
     const { root } = workspace();
     const pins = [
       { package: "@intentius/chant-lexicon-terraform", version: version(TERRAFORM), path: null },
-      { package: "@intentius/workspace-kind-choudoufu", version: version(CHOUDOUFU), path: null },
     ];
     const { registry, problems } = loadKindRegistry(pins, root);
     expect(problems).toEqual([]);
     expect(registry.get("terraform")).toMatchObject({ source: "@intentius/chant-lexicon-terraform", precedence: 400 });
-    expect(registry.get("choudoufu")).toMatchObject({ source: "@intentius/workspace-kind-choudoufu", precedence: 450 });
+    expect(registry.get("choudoufu")).toMatchObject({ source: "@intentius/chant-lexicon-terraform", precedence: 450 });
     const tree = workingTree(root);
     const winner = (dir: string) => resolveKind(registry, tree, dir).winner?.name;
     expect(winner("estates/stock")).toBe("terraform");

package/src/workspace/lineage-cli.ts

@@ -11,7 +11,7 @@
 
 import { formatError, formatSuccess } from "../cli/format";
 import type { CommandContext } from "../cli/registry";
-import { LOCK_FILE, LockError, readLock, resolveManualStep, scopeStatus, writeLock, type ManualStep } from "./lineage-lock";
+import { LOCK_FILE, LockError, readLock, resolveManualStep, scopeStatus, writeLock, type LineageSource, type ManualStep } from "./lineage-lock";
 
 const USAGE = "chant workspace lineage [--json] | chant workspace lineage resolve <path>";
 
@@ -20,6 +20,8 @@ export interface LineageScopeView {
   kind: "template" | "vendor";
   name?: string;
   template: string;
+  /** Where the files came from, as the lock records it: its `type` and the repository, directory, lexicon or URL. */
+  source: LineageSource;
   ref?: string;
   address: Record<string, unknown> | null;
   files: number;
@@ -28,6 +30,22 @@ export interface LineageScopeView {
   manualSteps: ManualStep[];
 }
 
+/** One line naming a scope's source kind and where it points (#2647). */
+export function describeSource(source: LineageSource): string {
+  switch (source.type) {
+    case "git":
+      return `git ${source.repo}${source.path ? `#${source.path}` : ""}`;
+    case "dir":
+      return `dir ${source.path}${source.member ? `#${source.member}` : ""}`;
+    case "lexicon":
+      return `lexicon ${source.lexicon}/${source.template}`;
+    case "local":
+      return `local ${source.path}`;
+    case "archive":
+      return `archive ${source.url}${source.subpath ? `#${source.subpath}` : ""}`;
+  }
+}
+
 /** The lock as `--json` prints it: one view per scope, with its state in the tree. */
 export function lineageView(root: string): { lock: string; scopes: LineageScopeView[] } | null {
   const lock = readLock(root);
@@ -39,6 +57,7 @@ export function lineageView(root: string): { lock: string; scopes: LineageScopeV
       kind: lineage.kind,
       ...(lineage.name !== undefined ? { name: lineage.name } : {}),
       template: lineage.template,
+      source: lineage.source,
       ...(lineage.ref !== undefined ? { ref: lineage.ref } : {}),
       address: lineage.address,
       files: Object.keys(lineage.files).length,
@@ -73,6 +92,7 @@ export async function runWorkspaceLineage(ctx: CommandContext): Promise<number>
       const pin = s.ref ? `@${s.ref}` : "";
       const at = typeof s.address?.commit === "string" ? ` (${s.address.commit.slice(0, 12)})` : "";
       lines.push(`${s.scope}  ${s.kind}${s.name ? ` ${s.name}` : ""}  ${s.template}${pin}${at}`);
+      lines.push(`  source: ${describeSource(s.source)}`);
       lines.push(`  ${s.files} file(s), ${s.edited.length} edited, ${s.missing.length} deleted`);
       for (const m of s.manualSteps) lines.push(`  manual step: ${s.scope === "." ? "" : `${s.scope}/`}${m.path} (${m.reason})`);
     }

package/src/workspace/lineage-init-dir.test.ts

@@ -0,0 +1,243 @@
+/**
+ * chant #2647: `chant init --from <dir>[#<member>]`, a template directory on
+ * disk. The same files and parameters as the git form for the same tree, a
+ * lock whose address is the digest alone, and `chant workspace upgrade`
+ * from a directory, which rebuilds its merge base only while the recorded
+ * directory still holds what the scope was made from.
+ */
+
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { execFileSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { initFromCommand, parseDirSpec, recordedDirPath } from "./lineage-init";
+import { LOCK_FILE, readLock } from "./lineage-lock";
+import { describeSource, lineageView } from "./lineage-cli";
+import { stageUpgrade, type ChantRunner } from "./lineage-upgrade";
+
+const ENV = { ...process.env, GIT_AUTHOR_NAME: "t", GIT_AUTHOR_EMAIL: "t@t", GIT_COMMITTER_NAME: "t", GIT_COMMITTER_EMAIL: "t@t" };
+
+let root: string;
+
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, { cwd, encoding: "utf-8", env: ENV, stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+function put(base: string, rel: string, content: string): void {
+  mkdirSync(dirname(join(base, rel)), { recursive: true });
+  writeFileSync(join(base, rel), content);
+}
+function read(base: string, rel: string): string {
+  return readFileSync(join(base, rel), "utf-8");
+}
+/** Every file under `dir` except the lock, with its content and executable bit. */
+function tree(dir: string, prefix = ""): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const e of readdirSync(join(dir, prefix), { withFileTypes: true })) {
+    const rel = prefix ? `${prefix}/${e.name}` : e.name;
+    if (e.isDirectory()) Object.assign(out, tree(dir, rel));
+    else if (rel !== LOCK_FILE) out[rel] = `${statSync(join(dir, rel)).mode & 0o100 ? "x " : ""}${readFileSync(join(dir, rel), "utf-8")}`;
+  }
+  return out;
+}
+
+/** A template directory with a manifest, an executable, a seed and a lock of its own. */
+function writeTemplate(dir: string, version = "1"): void {
+  put(dir, "svc/README.md", `template v${version}\n`);
+  put(dir, "svc/src/main.ts", 'export const name = "{{chant:name}}";\n');
+  put(dir, "svc/run.sh", "#!/bin/sh\n");
+  execFileSync("chmod", ["+x", join(dir, "svc/run.sh")]);
+  put(dir, "svc/.mcp.json", "{}\n");
+  put(dir, `svc/${LOCK_FILE}`, JSON.stringify({ lockVersion: 1, scopes: {} }));
+  put(
+    dir,
+    "svc/chant.template.json",
+    JSON.stringify({ parameters: { name: { type: "string", default: "app" }, owner: { type: "string", default: "ops" } }, files: ["src/main.ts"] }),
+  );
+}
+
+beforeEach(() => {
+  root = realpathSync(mkdtempSync(join(tmpdir(), "chant-init-dir-test-")));
+  vi.spyOn(console, "log").mockImplementation(() => undefined);
+  vi.spyOn(console, "error").mockImplementation(() => undefined);
+});
+afterEach(() => {
+  vi.restoreAllMocks();
+  rmSync(root, { recursive: true, force: true });
+});
+
+describe("parseDirSpec", () => {
+  test("an existing directory is the directory form, with or without #<member>", () => {
+    mkdirSync(join(root, "tpl", "svc"), { recursive: true });
+    expect(parseDirSpec("tpl#svc", root)).toEqual({ kind: "dir", path: "tpl", abs: join(root, "tpl"), member: "svc" });
+    expect(parseDirSpec(join(root, "tpl"), root)).toEqual({ kind: "dir", path: join(root, "tpl"), abs: join(root, "tpl") });
+  });
+  test("a directory whose name parses as <repo>@<ref> is still a directory", () => {
+    mkdirSync(join(root, "starter@v1"));
+    expect(parseDirSpec("starter@v1", root)).toMatchObject({ kind: "dir", abs: join(root, "starter@v1") });
+  });
+  test("<repo>@<ref> with no such directory is the git form", () => {
+    expect(parseDirSpec("acme/starter@v1.2.0#service", root)).toBeNull();
+  });
+  test("a path with no @ that is not a directory is refused", () => {
+    expect(() => parseDirSpec("missing", root)).toThrow(/no directory missing, and not <repo>@<ref>/);
+    put(root, "file", "x");
+    expect(() => parseDirSpec("file", root)).toThrow(/file is not a directory/);
+    mkdirSync(join(root, "tpl"));
+    expect(() => parseDirSpec("tpl#../x", root)).toThrow(/not a directory in the directory/);
+  });
+  test("a relative directory is recorded from the project, an absolute one as given", () => {
+    expect(recordedDirPath("../tpl", join(root, "tpl"), join(root, "proj"))).toBe("../tpl");
+    expect(recordedDirPath("tpl", join(root, "tpl"), root)).toBe("./tpl");
+    expect(recordedDirPath(join(root, "tpl"), join(root, "tpl"), join(root, "proj"))).toBe(join(root, "tpl"));
+  });
+});
+
+describe("chant init --from <dir>", () => {
+  test("copies the same files, with the same parameters and digest, as the git form of the same tree", async () => {
+    const tpl = join(root, "tpl");
+    writeTemplate(tpl);
+    git(tpl, ["init", "-q", "-b", "main"]);
+    git(tpl, ["add", "-A"]);
+    git(tpl, ["commit", "-q", "-m", "v1"]);
+
+    const fromGit = await initFromCommand({ from: `${tpl}@main#svc`, path: join(root, "a"), params: { name: "billing" } });
+    const fromDir = await initFromCommand({ from: `${tpl}#svc`, path: join(root, "b"), params: { name: "billing" } });
+    expect(fromGit.error).toBeUndefined();
+    expect(fromDir.error).toBeUndefined();
+    expect(fromDir.createdFiles).toEqual(fromGit.createdFiles);
+    expect(tree(join(root, "b"))).toEqual(tree(join(root, "a")));
+    expect(read(join(root, "b"), "src/main.ts")).toBe('export const name = "billing";\n');
+    expect(statSync(join(root, "b", "run.sh")).mode & 0o111).not.toBe(0);
+    expect(existsSync(join(root, "b", "chant.template.json"))).toBe(false);
+
+    const a = readLock(join(root, "a"))!.scopes["."];
+    const b = readLock(join(root, "b"))!.scopes["."];
+    expect(b.parameters).toEqual({ name: "billing", owner: "ops" });
+    expect(b.parameters).toEqual(a.parameters);
+    expect(b.files).toEqual(a.files);
+    expect(b.address).toEqual({ digest: a.address!.digest });
+    // The lock shape: the digest alone, a dir source, no ref.
+    expect(b.source).toEqual({ type: "dir", path: tpl, member: "svc" });
+    expect(b.template).toBe(`dir:${tpl}#svc`);
+    expect(b.ref).toBeUndefined();
+    expect(fromDir.template).toBe(`dir:${tpl}#svc`);
+    expect(fromDir.commit).toBeUndefined();
+    expect(a.source).toMatchObject({ type: "git", path: "svc" });
+  });
+
+  test("inside a git checkout, .gitignore is respected and untracked files are copied", async () => {
+    const tpl = join(root, "tpl");
+    git(root, ["init", "-q", "-b", "main"]);
+    put(tpl, "keep.ts", "keep\n");
+    put(tpl, ".gitignore", "out/\n*.log\n");
+    put(tpl, "out/built.js", "built\n");
+    put(tpl, "debug.log", "noise\n");
+    git(root, ["add", "tpl/keep.ts", "tpl/.gitignore"]);
+    git(root, ["commit", "-q", "-m", "t"]);
+    put(tpl, "untracked.ts", "new\n");
+
+    const result = await initFromCommand({ from: tpl, path: join(root, "proj") });
+    expect(result.error).toBeUndefined();
+    expect(result.createdFiles.sort()).toEqual([".gitignore", LOCK_FILE, "keep.ts", "untracked.ts"].sort());
+  });
+
+  test("outside git every file is copied, except node_modules, symbolic links and the template's own lock", async () => {
+    const tpl = join(root, "tpl");
+    writeTemplate(tpl);
+    put(tpl, "svc/.gitignore", "*.log\n");
+    put(tpl, "svc/debug.log", "copied: no git to read .gitignore\n");
+    put(tpl, "svc/node_modules/dep/index.js", "x\n");
+    symlinkSync("README.md", join(tpl, "svc", "link.md"));
+
+    const result = await initFromCommand({ from: `${tpl}#svc`, path: join(root, "proj") });
+    expect(result.error).toBeUndefined();
+    expect(result.createdFiles.sort()).toEqual([".gitignore", ".mcp.json", LOCK_FILE, "README.md", "debug.log", "run.sh", "src/main.ts"].sort());
+    expect(result.warnings).toEqual(["link.md is a symbolic link, not copied", "node_modules is node_modules, not copied"]);
+    expect(readLock(join(root, "proj"))!.scopes["."].files).not.toHaveProperty(LOCK_FILE);
+  });
+
+  test("refuses a missing member, a missing directory and an undeclared --param, writing nothing", async () => {
+    const tpl = join(root, "tpl");
+    writeTemplate(tpl);
+    const target = join(root, "proj");
+    expect((await initFromCommand({ from: `${tpl}#nope`, path: target })).error).toBe(`${tpl} has no directory nope`);
+    expect((await initFromCommand({ from: join(root, "missing"), path: target })).error).toMatch(/no directory .*missing, and not <repo>@<ref>/);
+    expect((await initFromCommand({ from: `${tpl}#svc`, path: target, params: { title: "x" } })).error).toBe("unknown parameter title (declared: name, owner)");
+    expect(existsSync(target)).toBe(false);
+  });
+
+  test("chant workspace lineage names the source kind and path", async () => {
+    const tpl = join(root, "tpl");
+    writeTemplate(tpl);
+    await initFromCommand({ from: `${tpl}#svc`, path: join(root, "proj") });
+    const view = lineageView(join(root, "proj"))!;
+    expect(view.scopes[0].source).toEqual({ type: "dir", path: tpl, member: "svc" });
+    expect(describeSource(view.scopes[0].source)).toBe(`dir ${tpl}#svc`);
+    expect(describeSource({ type: "git", repo: "acme/starter", url: "https://github.com/acme/starter.git", path: "svc" })).toBe("git acme/starter#svc");
+  });
+});
+
+describe("chant workspace upgrade on a directory scope", () => {
+  const passing: ChantRunner = async () => ({ exitCode: 0, output: "" });
+  let v1: string;
+  let v2: string;
+  let proj: string;
+
+  beforeEach(async () => {
+    v1 = join(root, "bundle-v1");
+    v2 = join(root, "bundle-v2");
+    proj = join(root, "proj");
+    writeTemplate(v1);
+    put(v1, "svc/src/lib.ts", "one\ntwo\nthree\nfour\nfive\nsix\nseven\n");
+    const made = await initFromCommand({ from: `${v1}#svc`, path: proj, params: { name: "billing" } });
+    expect(made.error).toBeUndefined();
+    git(proj, ["init", "-q", "-b", "main"]);
+    put(proj, "src/lib.ts", "ONE (ours)\ntwo\nthree\nfour\nfive\nsix\nseven\n");
+    git(proj, ["add", "-A"]);
+    git(proj, ["commit", "-q", "-m", "init and edit"]);
+
+    cpSync(v1, v2, { recursive: true });
+    put(v2, "svc/README.md", "template v2\n");
+    put(v2, "svc/src/lib.ts", "one\ntwo\nthree\nfour\nfive\nsix\nSEVEN (theirs)\n");
+    put(v2, "svc/src/new.ts", "new\n");
+  });
+
+  test("without --to it refuses, naming adopt-lineage", async () => {
+    await expect(stageUpgrade({ root: proj, runChant: passing })).rejects.toThrow(/no --to directory\. .*has no git history.*chant workspace adopt-lineage/);
+  });
+
+  test("with --to a directory, the recorded directory is the merge base while it holds the same digest", async () => {
+    const staged = await stageUpgrade({ root: proj, to: v2, runChant: passing });
+    try {
+      expect(staged.merged).toEqual(["src/lib.ts"]);
+      expect(staged.written.sort()).toEqual(["README.md", "src/new.ts"]);
+      expect(staged.manualSteps).toEqual([]);
+      expect(staged.from).toBe(`${v1}#svc`);
+      expect(staged.to).toBe(`${v2}#svc`);
+      expect(read(staged.worktreeProject, "src/lib.ts")).toBe("ONE (ours)\ntwo\nthree\nfour\nfive\nsix\nSEVEN (theirs)\n");
+      // The parameter carried into the new version's files.
+      expect(read(staged.worktreeProject, "src/main.ts")).toBe('export const name = "billing";\n');
+      const lock = readLock(staged.worktreeProject)!.scopes["."];
+      expect(lock.source).toEqual({ type: "dir", path: v2, member: "svc" });
+      expect(Object.keys(lock.address!)).toEqual(["digest"]);
+      expect(lock.ref).toBeUndefined();
+      expect(lock.parameters).toEqual({ name: "billing", owner: "ops" });
+    } finally {
+      staged.dispose();
+    }
+  });
+
+  test("refuses when the recorded directory changed or is gone, naming adopt-lineage", async () => {
+    put(v1, "svc/README.md", "replaced in place\n");
+    await expect(stageUpgrade({ root: proj, to: v2, runChant: passing })).rejects.toThrow(
+      /no longer holds the files the scope was made from.*chant workspace adopt-lineage/,
+    );
+    rmSync(v1, { recursive: true, force: true });
+    await expect(stageUpgrade({ root: proj, to: v2, runChant: passing })).rejects.toThrow(/is gone\. .*chant workspace adopt-lineage/);
+  });
+
+  test("--to must be a directory", async () => {
+    await expect(stageUpgrade({ root: proj, to: "v2.0.0", runChant: passing })).rejects.toThrow(/--to v2\.0\.0: a scope made from a directory upgrades from a directory/);
+  });
+});

package/src/workspace/lineage-init.ts

@@ -4,9 +4,14 @@
  * with one lineage, scope `"."`, so a project made from a template can be
  * upgraded later without first running adopt-lineage.
  *
- * `--from` fetches with `git`: the one network step, listed in the egress
- * catalogue (`test/egress-catalogue.ts`). The commit and the tree of the
- * chosen directory become the content address.
+ * `--from <repo>@<ref>` fetches with `git`: the one network step, listed in
+ * the egress catalogue (`test/egress-catalogue.ts`). The commit and the tree
+ * of the chosen directory become the content address.
+ *
+ * `--from <dir>[#<member>]` copies a template directory already on disk
+ * (#2647), for a host that carries the template as plain files with no
+ * `.git` and no way to reach its repository. It reaches no network, and the
+ * digest of the copied files is the whole content address.
  *
  * Plain `chant init` without `--template` writes no lock. That keeps the
  * output of an existing command unchanged (#2525 rule 2), and this module
@@ -14,7 +19,7 @@
  */
 
 import { execFileSync } from "node:child_process";
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
@@ -46,24 +51,30 @@ export interface TemplateSpec {
   id: string;
 }
 
-/**
- * Parse `<repo>@<ref>[#<member>]`. `<repo>` is a git URL, an scp-style
- * `git@host:path`, a local path, or `owner/name` for a GitHub repository.
- */
-export function parseTemplateSpec(spec: string, cwd: string = process.cwd()): TemplateSpec {
+/** Split `<spec>[#<member>]`, refusing a member that leaves the template. */
+function splitMember(spec: string, where: string): { rest: string; member?: string } {
   let rest = spec.trim();
   let member: string | undefined;
   const hash = rest.lastIndexOf("#");
   if (hash >= 0) {
     member = rest.slice(hash + 1).replace(/^\/+|\/+$/g, "");
     rest = rest.slice(0, hash);
-    if (!member || posix.normalize(member).startsWith("..")) throw new LockError(`--from ${spec}: "#${member}" is not a directory in the repository`);
+    if (!member || posix.normalize(member).startsWith("..")) throw new LockError(`--from ${spec}: "#${member}" is not a directory in ${where}`);
     member = posix.normalize(member);
   }
+  return { rest, member };
+}
+
+/**
+ * Parse `<repo>@<ref>[#<member>]`. `<repo>` is a git URL, an scp-style
+ * `git@host:path`, a local path, or `owner/name` for a GitHub repository.
+ */
+export function parseTemplateSpec(spec: string, cwd: string = process.cwd()): TemplateSpec {
+  const { rest, member } = splitMember(spec, "the repository");
   const at = rest.lastIndexOf("@");
   const lastSep = Math.max(rest.lastIndexOf("/"), rest.lastIndexOf(":"));
   if (at <= 0 || at < lastSep || at === rest.length - 1) {
-    throw new LockError(`--from ${spec}: expected <repo>@<ref>[#<member>], e.g. acme/starter@v1.2.0`);
+    throw new LockError(`--from ${spec}: expected <repo>@<ref>[#<member>], e.g. acme/starter@v1.2.0, or an existing directory`);
   }
   const repo = rest.slice(0, at);
   const ref = rest.slice(at + 1);
@@ -181,9 +192,162 @@ export function fetchTemplate(spec: TemplateSpec): FetchedTemplate {
   }
 }
 
+// ── A template directory on disk (#2647) ─────────────────────────────────────
+
+export interface DirTemplateSpec {
+  kind: "dir";
+  /** The directory as written, without `#<member>`. */
+  path: string;
+  /** The directory, absolute. */
+  abs: string;
+  /** The directory inside it to instantiate (`#<member>`). */
+  member?: string;
+}
+
+/**
+ * Parse `<path>[#<member>]` when `<path>` is an existing directory, or return
+ * null for the git form. A spec without `@` that names no directory is
+ * refused here, since it cannot be a `<repo>@<ref>` either. A directory whose
+ * name happens to parse as `<repo>@<ref>` is a directory: what is on disk wins.
+ */
+export function parseDirSpec(spec: string, cwd: string = process.cwd()): DirTemplateSpec | null {
+  const { rest, member } = splitMember(spec, "the directory");
+  if (!rest) return null;
+  const abs = resolve(cwd, rest);
+  let isDir = false;
+  try {
+    isDir = statSync(abs).isDirectory();
+  } catch {
+    isDir = false;
+  }
+  if (isDir) return { kind: "dir", path: rest, abs, ...(member ? { member } : {}) };
+  if (rest.includes("@")) return null;
+  if (existsSync(abs)) throw new LockError(`--from ${spec}: ${rest} is not a directory`);
+  throw new LockError(`--from ${spec}: no directory ${rest}, and not <repo>@<ref>[#<member>] (e.g. acme/starter@v1.2.0)`);
+}
+
+/** The template's directory as `#<member>` names it, relative to its root, for messages. */
+export function dirLabel(path: string, member?: string): string {
+  return member ? `${path}#${member}` : path;
+}
+
+/** The git work tree `dir` sits in, or null when it is in none, git is not installed, or the work tree ignores `dir`. */
+function workTreeOf(dir: string): string | null {
+  try {
+    if (git(dir, ["rev-parse", "--is-inside-work-tree"]) !== "true") return null;
+    const top = git(dir, ["rev-parse", "--show-toplevel"]);
+    const rel = relative(top, dir).split(sep).join("/");
+    if (rel) {
+      try {
+        // Exit 0: ignored. A directory the checkout ignores is copied whole.
+        git(top, ["check-ignore", "-q", "--", `${rel}/`]);
+        return null;
+      } catch {
+        // Not ignored.
+      }
+    }
+    return top;
+  } catch {
+    return null;
+  }
+}
+
+/** Every path under `dir`, relative and posix, except `.git`. Symbolic links are listed, not followed. */
+function walk(dir: string, prefix = ""): string[] {
+  const out: string[] = [];
+  for (const entry of readdirSync(join(dir, prefix), { withFileTypes: true })) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.name === ".git") continue;
+    if (entry.isDirectory()) out.push(...walk(dir, rel));
+    else out.push(rel);
+  }
+  return out;
+}
+
+/**
+ * Read the files of a template directory on disk, the way
+ * {@link readTemplateTree} reads a commit: symbolic links, submodules and the
+ * template's own lineage lock are skipped with the reason, and so is
+ * `node_modules`. Inside a git checkout the files are the ones git would
+ * commit, tracked or untracked but not ignored. Elsewhere, or when git is not
+ * installed, every file is copied. The executable bit is the owner's.
+ */
+export function readTemplateDir(abs: string, member: string | undefined, label: string): Omit<FetchedTemplate, "commit" | "tree"> {
+  const dir = member ? join(abs, member) : abs;
+  let isDir = false;
+  try {
+    isDir = statSync(dir).isDirectory();
+  } catch {
+    isDir = false;
+  }
+  if (!isDir) throw new LockError(`${label} has no directory ${member ?? ""}`.trimEnd());
+
+  let paths: string[];
+  if (workTreeOf(dir)) {
+    const listing = execFileSync("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", "."], {
+      cwd: dir,
+      maxBuffer: 256 * 1024 * 1024,
+    }).toString("utf-8");
+    paths = [...new Set(listing.split("\0").filter(Boolean))];
+  } else {
+    paths = walk(dir);
+  }
+
+  const files: FetchedTemplate["files"] = new Map();
+  const skipped: FetchedTemplate["skipped"] = [];
+  const skippedModules = new Set<string>();
+  for (const path of paths.sort()) {
+    const segments = path.split("/");
+    const nm = segments.indexOf("node_modules");
+    if (nm >= 0) {
+      const at = segments.slice(0, nm + 1).join("/");
+      if (!skippedModules.has(at)) {
+        skippedModules.add(at);
+        skipped.push({ path: at, reason: "node_modules" });
+      }
+      continue;
+    }
+    if (path === LOCK_FILE) {
+      skipped.push({ path, reason: "the template's own lineage lock" });
+      continue;
+    }
+    let st;
+    try {
+      st = lstatSync(join(dir, path));
+    } catch {
+      // Tracked but deleted from the working files: not part of the template on disk.
+      continue;
+    }
+    if (st.isSymbolicLink()) {
+      skipped.push({ path, reason: "a symbolic link" });
+      continue;
+    }
+    if (st.isDirectory()) {
+      skipped.push({ path, reason: "a submodule" });
+      continue;
+    }
+    if (!st.isFile()) {
+      skipped.push({ path, reason: "not a regular file" });
+      continue;
+    }
+    files.set(path, { data: readFileSync(join(dir, path)), executable: (st.mode & 0o100) !== 0 });
+  }
+  return { files, skipped };
+}
+
+/**
+ * How a directory source is recorded: an absolute path as given, a relative
+ * one re-expressed from the project, so it resolves from the lock's directory.
+ */
+export function recordedDirPath(given: string, abs: string, projectDir: string): string {
+  if (isAbsolute(given)) return abs;
+  return portableUrl(abs, projectDir);
+}
+
 // ── init --from ──────────────────────────────────────────────────────────────
 
 export interface InitFromOptions {
+  /** `<repo>@<ref>[#<member>]`, or `<dir>[#<member>]` for a directory on disk (#2647). */
   from: string;
   /** Target directory (defaults to cwd). */
   path?: string;
@@ -197,21 +361,28 @@ export interface InitFromResult {
   createdFiles: string[];
   warnings: string[];
   error?: string;
+  /** The git form's spec. */
   spec?: TemplateSpec;
+  /** The directory form's spec (#2647). */
+  dir?: DirTemplateSpec;
   commit?: string;
+  /** The lineage's `template` id. */
+  template?: string;
   /** The parameter values used, recorded in the lock. */
   parameters?: Record<string, string>;
 }
 
-/** `chant init --from <repo>@<ref>[#<member>] [path]`. */
+/** `chant init --from <repo>@<ref>[#<member>] [path]`, or `--from <dir>[#<member>]`. */
 export async function initFromCommand(options: InitFromOptions): Promise<InitFromResult> {
   const targetDir = resolve(options.path ?? ".");
   const warnings: string[] = [];
   const createdFiles: string[] = [];
 
-  let spec: TemplateSpec;
+  let spec: TemplateSpec | undefined;
+  let dir: DirTemplateSpec | undefined;
   try {
-    spec = parseTemplateSpec(options.from);
+    dir = parseDirSpec(options.from) ?? undefined;
+    if (!dir) spec = parseTemplateSpec(options.from);
   } catch (err) {
     return { success: false, createdFiles, warnings, error: (err as Error).message };
   }
@@ -227,9 +398,10 @@ export async function initFromCommand(options: InitFromOptions): Promise<InitFro
     return { success: false, createdFiles, warnings, error: `${LOCK_FILE} already exists; this directory already has a lineage` };
   }
 
-  let fetched: FetchedTemplate;
+  let fetched: Omit<FetchedTemplate, "commit" | "tree"> & { commit?: string; tree?: string };
   try {
-    fetched = fetchTemplate(spec);
+    // Every file is read before anything is written, so a target inside the template directory is safe.
+    fetched = dir ? readTemplateDir(dir.abs, dir.member, dir.path) : fetchTemplate(spec!);
   } catch (err) {
     return { success: false, createdFiles, warnings, error: (err as Error).message };
   }
@@ -268,23 +440,46 @@ export async function initFromCommand(options: InitFromOptions): Promise<InitFro
     createdFiles.push(path);
   }
 
-  const lineage: Lineage = {
-    kind: "template",
-    template: spec.id,
-    source: { type: "git", repo: spec.repo, url: portableUrl(spec.url, targetDir), ...(spec.member ? { path: spec.member } : {}) },
-    ref: spec.ref,
-    address: { digest: contentDigest(written), commit: fetched.commit, tree: fetched.tree },
+  const common = {
     parameters,
     migrations: [],
     files: fileEntries(written, declaredFilesAt(targetDir)),
     manualSteps: [],
   };
+  let lineage: Lineage;
+  if (dir) {
+    const path = recordedDirPath(dir.path, dir.abs, targetDir);
+    lineage = {
+      kind: "template",
+      template: `dir:${dirLabel(path, dir.member)}`,
+      source: { type: "dir", path, ...(dir.member ? { member: dir.member } : {}) },
+      address: { digest: contentDigest(written) },
+      ...common,
+    };
+  } else {
+    lineage = {
+      kind: "template",
+      template: spec!.id,
+      source: { type: "git", repo: spec!.repo, url: portableUrl(spec!.url, targetDir), ...(spec!.member ? { path: spec!.member } : {}) },
+      ref: spec!.ref,
+      address: { digest: contentDigest(written), commit: fetched.commit, tree: fetched.tree },
+      ...common,
+    };
+  }
   const lock = emptyLock();
   lock.scopes["."] = lineage;
   writeLock(targetDir, lock);
   createdFiles.push(LOCK_FILE);
 
-  return { success: true, createdFiles, warnings, spec, commit: fetched.commit, parameters };
+  return {
+    success: true,
+    createdFiles,
+    warnings,
+    ...(spec ? { spec, commit: fetched.commit } : {}),
+    ...(dir ? { dir } : {}),
+    template: lineage.template,
+    parameters,
+  };
 }
 
 /** A local repository is recorded relative to the project, so the lock does not name this machine's paths. */

package/src/workspace/lineage-lock.ts

@@ -4,8 +4,9 @@
  * The lock records where a project's files came from. It holds one lineage per
  * scope, keyed by the scope's directory relative to the lock's root:
  *
- * - a project made by `chant init --from <repo>@<ref>` or
- *   `chant init --template <name>` has one scope, `"."`;
+ * - a project made by `chant init --from <repo>@<ref>`,
+ *   `chant init --from <dir>` or `chant init --template <name>` has one
+ *   scope, `"."`;
  * - each `chant vendor` target is a scope of kind `vendor` (copied, no
  *   parameters), which replaces its entry in `vendor.json` (ws-038).
  *
@@ -65,6 +66,12 @@ const LockFileEntrySchema = z
 const SourceSchema = z.discriminatedUnion("type", [
   /** A git repository at a ref, optionally one directory of it (`#<member>`). */
   z.object({ type: z.literal("git"), repo: z.string().min(1), url: z.string().min(1), path: z.string().optional() }).strict(),
+  /**
+   * A directory on disk (#2647): `path` as given when absolute, otherwise
+   * relative to the lock's directory, and `member` for `#<member>`. It has no
+   * history, so its address is the digest alone.
+   */
+  z.object({ type: z.literal("dir"), path: z.string().min(1), member: z.string().optional() }).strict(),
   /** A lexicon's `initTemplates`, as `chant init --lexicon <lexicon> --template <template>` renders them. */
   z.object({ type: z.literal("lexicon"), lexicon: z.string().min(1), template: z.string().min(1) }).strict(),
   /** `chant vendor` sources, unchanged from `vendor.json`. */
@@ -78,7 +85,8 @@ export type LineageSource = z.infer<typeof SourceSchema>;
  * `digest` is always present: the content hash of the file set as chant wrote
  * it (the same hash `vendor.json` called `checksum`). A git source adds the
  * commit and the tree of the scope's directory; a lexicon template adds the
- * package and chant versions that rendered it.
+ * package and chant versions that rendered it. A directory source has the
+ * digest only.
  */
 const AddressSchema = z
   .object({

package/src/workspace/lineage-upgrade-cli.ts

@@ -1,5 +1,5 @@
 /**
- * `chant workspace upgrade [<scope>] [--to <ref>] [--allow-code] [--dry-run]
+ * `chant workspace upgrade [<scope>] [--to <ref|dir>] [--allow-code] [--dry-run]
  * [--output <file>] [--json]` (#2550).
  *
  * Stages the upgrade in a worktree (see ./lineage-upgrade.ts), then decides
@@ -20,7 +20,7 @@ import { WORKSPACE_UPGRADE_GATE_OP } from "../op/gate-name";
 import { LockError } from "./lineage-lock";
 import { applyStagedUpgrade, describeStaged, stageUpgrade, type ChantRunner, type StagedUpgrade } from "./lineage-upgrade";
 
-const USAGE = "chant workspace upgrade [<scope>] [--to <ref>] [--allow-code] [--dry-run] [--output <patch file>] [--json]";
+const USAGE = "chant workspace upgrade [<scope>] [--to <ref|dir>] [--allow-code] [--dry-run] [--output <patch file>] [--json]";
 
 /** The exit code of a gated upgrade: the same as `chant run`'s gated run. */
 export const UPGRADE_GATED_EXIT = 3;

package/src/workspace/lineage-upgrade.ts

@@ -9,7 +9,8 @@
  * 1. Fetch the target version of the template. For a git source that is one
  *    `git fetch` of the target ref, plus the commit the scope was made from.
  *    This is the command's only network step, catalogued in
- *    `test/egress-catalogue.ts`. A local repository reaches nothing.
+ *    `test/egress-catalogue.ts`. A local repository reaches nothing, and
+ *    neither does a directory source (#2647), which reads `--to <dir>`.
  * 2. Rebuild the merge base offline: each recorded file's content at the base
  *    commit, kept only when it has the hash the lock recorded. A file the
  *    project never edited is its own merge base. Vendor sources keep no
@@ -39,8 +40,21 @@ import { basename, join, relative, resolve, sep } from "node:path";
 import { computePlanDigest } from "../lifecycle/plan-digest";
 import type { ResolvedGateApproval } from "../op/gate-approval";
 import { checkLineage, findingKey, type CheckFinding } from "./lineage-check";
-import { git, readTemplateTree } from "./lineage-init";
-import { LOCK_FILE, LockError, fileHash, readLock, renderLock, scopeKey, writeLock, type Lineage, type LineageLock, type ManualStep } from "./lineage-lock";
+import { dirLabel, git, parseDirSpec, readTemplateDir, readTemplateTree, recordedDirPath } from "./lineage-init";
+import {
+  LOCK_FILE,
+  LockError,
+  contentDigest,
+  fileHash,
+  readLock,
+  renderLock,
+  scopeKey,
+  writeLock,
+  type Lineage,
+  type LineageLock,
+  type LineageSource,
+  type ManualStep,
+} from "./lineage-lock";
 import { mergeFile } from "./lineage-merge";
 import { assertCodeAllowed, planMigrations, runMigration, splitMigrations, type LoadedMigration } from "./lineage-migrations";
 import { applyUpstream, type UpdateResult } from "./lineage-update";
@@ -95,7 +109,12 @@ export interface UpgradeOptions {
   root: string;
   /** The scope to upgrade: `"."` or a vendor scope's directory. */
   scope?: string;
-  /** The target ref (git) or label (vendor). Defaults to the ref the scope is pinned at. */
+  /**
+   * The target ref (git) or label (vendor). Defaults to the ref the scope is
+   * pinned at. For a directory source, the directory holding the new version,
+   * as `<dir>[#<member>]`, resolved from the current directory; the member
+   * defaults to the recorded one.
+   */
   to?: string;
   /** Run migrations whose body is code. */
   allowCode?: boolean;
@@ -163,8 +182,10 @@ interface Upstream {
   modules: Map<string, Buffer>;
   commit?: string;
   tree?: string;
-  /** The parameter values substituted into `files` (#2627), for a git source. */
+  /** The parameter values substituted into `files` (#2627), for a git or directory source. */
   parameters?: Record<string, string>;
+  /** The source the lock records after the upgrade, when it moves (a directory source). */
+  source?: LineageSource;
 }
 
 /**
@@ -249,6 +270,76 @@ function fetchGit(root: string, lineage: Lineage, ref: string): Upstream {
   }
 }
 
+/**
+ * Why a directory scope cannot be upgraded, with the way out. A directory
+ * has no history, so the merge base exists only while the files the scope
+ * was made from are still on disk.
+ */
+function dirRefusal(lineage: Lineage, why: string): UpgradeError {
+  const source = lineage.source as Extract<LineageSource, { type: "dir" }>;
+  return new UpgradeError(
+    `${why}. The scope was made from the directory ${dirLabel(source.path, source.member)}, which has no git history to rebuild a merge base from. ` +
+      `Upgrade with --to <dir> while ${source.path} still holds the files the scope was made from, or adopt the scope into a git lineage with \`chant workspace adopt-lineage\` (#2551).`,
+  );
+}
+
+/**
+ * The upstream of a directory source (#2647): the new version from the
+ * directory `to` names, and the merge base from the recorded directory, used
+ * only when its files, instantiated with the recorded parameters, still have
+ * the recorded digest. Anything else is refused: a base that is not the one
+ * the scope was made from would turn the project's edits into upstream
+ * changes. Reaches no network.
+ */
+function readDir(root: string, lineage: Lineage, to: string | undefined): Upstream {
+  const source = lineage.source;
+  if (source.type !== "dir") throw new UpgradeError("not a directory source");
+  if (!to) throw dirRefusal(lineage, "no --to directory");
+
+  let target;
+  try {
+    target = parseDirSpec(to);
+  } catch {
+    target = null;
+  }
+  if (!target) throw new UpgradeError(`--to ${to}: a scope made from a directory upgrades from a directory, and ${to} is not one`);
+  const member = to.includes("#") ? target.member : source.member;
+  const label = dirLabel(target.path, member);
+  const read = readTemplateDir(target.abs, member, label);
+  const raw = new Map<string, Buffer>();
+  const executable = new Set<string>();
+  for (const [path, f] of read.files) {
+    raw.set(path, f.data);
+    if (f.executable) executable.add(path);
+  }
+  const instantiated = instantiate(raw, lineage.parameters, label);
+
+  // The merge base: the recorded directory, only while it holds exactly what the scope was made from.
+  const original = resolve(root, source.path);
+  const originalLabel = dirLabel(source.path, source.member);
+  let base: Map<string, Buffer>;
+  try {
+    const old = readTemplateDir(original, source.member, originalLabel);
+    base = splitMigrations(instantiate(new Map([...old.files].map(([path, f]) => [path, f.data])), lineage.parameters, originalLabel).files).files;
+  } catch {
+    throw dirRefusal(lineage, `${originalLabel} is gone`);
+  }
+  if (!lineage.address || contentDigest(base) !== lineage.address.digest) {
+    throw dirRefusal(lineage, `${originalLabel} no longer holds the files the scope was made from (its digest is not ${lineage.address?.digest ?? "recorded"})`);
+  }
+
+  const split = splitMigrations(instantiated.files);
+  return {
+    files: split.files,
+    executable,
+    base,
+    migrations: split.migrations,
+    modules: split.modules,
+    parameters: instantiated.parameters,
+    source: { type: "dir", path: recordedDirPath(target.path, target.abs, root), ...(member ? { member } : {}) },
+  };
+}
+
 async function fetchUpstream(root: string, lineage: Lineage, ref: string | undefined): Promise<Upstream> {
   const source = lineage.source;
   if (source.type === "git") {
@@ -260,6 +351,7 @@ async function fetchUpstream(root: string, lineage: Lineage, ref: string | undef
     const files = await resolveVendorSource(source, root);
     return { files, executable: new Set(), base: new Map(), migrations: [], modules: new Map() };
   }
+  if (source.type === "dir") return readDir(root, lineage, ref);
   throw new UpgradeError(
     `scope made by \`chant init --template\` (${lineage.template}) cannot be upgraded yet: its merge base is the older lexicon's render, which is not available offline. Upgrade git-sourced and vendor scopes for now.`,
   );
@@ -404,9 +496,10 @@ export async function stageUpgrade(options: UpgradeOptions): Promise<StagedUpgra
     );
   }
 
-  // 1. Fetch.
-  const ref = options.to ?? lineage.ref;
-  const upstream = await fetchUpstream(root, lineage, ref);
+  // 1. Fetch. A directory source has no ref: `--to` names the directory.
+  const fromDir = lineage.source.type === "dir";
+  const ref = fromDir ? undefined : options.to ?? lineage.ref;
+  const upstream = await fetchUpstream(root, lineage, fromDir ? options.to : ref);
 
   // 2. The merge base, offline from here on.
   const base = rebuildBase(join(root, scope), lineage, upstream.base);
@@ -469,6 +562,7 @@ export async function stageUpgrade(options: UpgradeOptions): Promise<StagedUpgra
     if (ref !== undefined) staged.ref = ref;
     if (upstream.parameters) staged.parameters = upstream.parameters;
     if (upstream.commit) staged.address = { ...staged.address!, commit: upstream.commit, tree: upstream.tree };
+    if (upstream.source) staged.source = upstream.source;
     writeLock(worktreeProject, next);
     const lockText = renderLock(next);
 
@@ -512,8 +606,8 @@ export async function stageUpgrade(options: UpgradeOptions): Promise<StagedUpgra
       scope,
       template: lineage.template,
       kind: lineage.kind,
-      from: lineage.ref ?? null,
-      to: staged.ref ?? null,
+      from: fromDir ? sourcePin(lineage.source) : lineage.ref ?? null,
+      to: fromDir ? sourcePin(staged.source) : staged.ref ?? null,
       ...(upstream.commit ? { commit: { ...(lineage.address?.commit ? { from: lineage.address.commit } : {}), to: upstream.commit } } : {}),
       migrations: plan.chain.map((m) => m.migration.id),
       written: result.written,
@@ -542,6 +636,11 @@ export async function stageUpgrade(options: UpgradeOptions): Promise<StagedUpgra
   }
 }
 
+/** A directory source's pin, for the summary: the directory it reads. */
+function sourcePin(source: LineageSource): string | null {
+  return source.type === "dir" ? dirLabel(source.path, source.member) : null;
+}
+
 /**
  * `chant workspace check` in the worktree. A finding already present at HEAD
  * is not the upgrade's doing, and the upgrade's own manual steps are what the