@okfit/cli 0.2.0 → 0.4.0

package/index.js

@@ -1,17 +1,8 @@
-import { ConfigMalformedError, ConfigPathNotFoundError, InitOverwriteError, VerifyConceptNotFoundError, VerifyUnsupportedFrontmatterError, renderFailure } from "./errors.js";
-import { buildConfigLayer, provideConfig } from "./config/layer.js";
-import { resolveBundleRoot, resolveProjectRoot } from "./config/anchor.js";
-import { DEFAULT_PROFILE_NAME, resolveProjectConfig } from "./config/resolve.js";
-import { runContext } from "./context/run.js";
-import { ContextEnvelope, ContextTag, ContextType, contextEnvelope, humanContext } from "./render/context.js";
-import { forDiagnostics, tally } from "./render/exit.js";
-import { collect, sort } from "./render/sort.js";
-import { JsonDiagnostic, JsonEnvelope, JsonErrorEnvelope, JsonSummary, json, jsonError } from "./render/json.js";
+import { humanContext } from "./render/context.js";
 import { CLI_VERSION } from "./version.js";
-import { CONFIG_RELATIVE_PATH, configValue, files, targetPaths } from "./init/scaffold.js";
 import { human, line, summary } from "./render/human.js";
-import { run } from "./validate/run.js";
-import { VerifyEnvelope, humanVerify, verifyEnvelope } from "./render/verify.js";
+import { humanVerify } from "./render/verify.js";
 import { rootCommand } from "./commands/root.js";
+import { renderFailure } from "./errors.js";
 
-export { CLI_VERSION, CONFIG_RELATIVE_PATH, ConfigMalformedError, ConfigPathNotFoundError, ContextEnvelope, ContextTag, ContextType, DEFAULT_PROFILE_NAME, InitOverwriteError, JsonDiagnostic, JsonEnvelope, JsonErrorEnvelope, JsonSummary, VerifyConceptNotFoundError, VerifyEnvelope, VerifyUnsupportedFrontmatterError, buildConfigLayer, collect, configValue, contextEnvelope, files, forDiagnostics, human, humanContext, humanVerify, json, jsonError, line, provideConfig, renderFailure, resolveBundleRoot, resolveProjectConfig, resolveProjectRoot, rootCommand, run, runContext, sort, summary, tally, targetPaths, verifyEnvelope };
+export { CLI_VERSION, human, humanContext, humanVerify, line, renderFailure, rootCommand, summary };

package/main.d.ts

@@ -0,0 +1,15 @@
+//#region src/main.d.ts
+/**
+ * The assembled okfit CLI program.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Run the okfit CLI. Owns the process: installs the runtime teardown and
+ * sets the exit code. `NodeRuntime.runMain` does not return a promise.
+ *
+ * @public
+ */
+export declare const main: () => void;
+//#endregion
+//# sourceMappingURL=main.d.ts.map

package/main.js

@@ -0,0 +1,44 @@
+import { CLI_VERSION } from "./version.js";
+import { rootCommand } from "./commands/root.js";
+import { renderFailure } from "./errors.js";
+import { Command } from "effect/unstable/cli";
+import { Now, OkfitPlatform } from "@okfit/engine";
+import { DateTime, Effect, Option } from "effect";
+import { CliLogger, CliRuntime } from "@effected/cli";
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+
+//#region src/main.ts
+/**
+* The assembled okfit CLI program.
+*
+* @packageDocumentation
+*/
+/**
+* K-47: an ISO-8601 `OKFIT_NOW` when set, else the wall clock. A documented
+* test hook, not user-facing. Resolved exactly once, here, and provided to
+* the whole command tree through the `Now` tag so no command handler ever
+* reads `process.env["OKFIT_NOW"]` itself.
+*/
+const nowEffect = Option.fromNullishOr(process.env.OKFIT_NOW).pipe(Option.flatMap((iso) => DateTime.make(iso)), Option.match({
+	onNone: () => DateTime.now,
+	onSome: Effect.succeed
+}));
+/**
+* Run the okfit CLI. Owns the process: installs the runtime teardown and
+* sets the exit code. `NodeRuntime.runMain` does not return a promise.
+*
+* @public
+*/
+const main = () => {
+	const program = Effect.gen(function* () {
+		const now = yield* nowEffect;
+		return yield* Command.run(rootCommand, { version: CLI_VERSION }).pipe(Effect.provideService(Now, now), Effect.catchTag("ShowHelp", (help) => Effect.fail(CliRuntime.reported(help, help.errors.length > 0 ? 64 : 0))));
+	}).pipe(Effect.provide(OkfitPlatform), CliRuntime.reportFailures({
+		exitCode: 3,
+		render: renderFailure
+	}));
+	NodeRuntime.runMain(program.pipe(Effect.provide(CliLogger.layer())));
+};
+
+//#endregion
+export { main };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@okfit/cli",
-	"version": "0.2.0",
+	"version": "0.4.0",
 	"private": false,
 	"description": "The okfit command line: validate, lint, index, and inspect Open Knowledge Format (OKF) bundles.",
 	"keywords": [
@@ -31,6 +31,11 @@
 			"import": "./index.js",
 			"default": "./index.js"
 		},
+		"./main": {
+			"types": "./main.d.ts",
+			"import": "./main.js",
+			"default": "./main.js"
+		},
 		"./package.json": "./package.json"
 	},
 	"bin": {
@@ -38,20 +43,18 @@
 	},
 	"dependencies": {
 		"@effect/platform-node": "4.0.0-rc.112",
-		"@effected/app": "^0.15.0",
 		"@effected/cli": "^0.3.1",
 		"@effected/config-file": "^0.7.0",
 		"@effected/git": "^0.12.0",
 		"@effected/glob": "^0.5.0",
 		"@effected/jsonc": "^0.9.0",
 		"@effected/markdown": "^0.9.1",
-		"@effected/store": "^0.7.0",
 		"@effected/toml": "^0.6.0",
 		"@effected/walker": "^0.7.0",
-		"@effected/xdg": "^0.4.1",
 		"@effected/yaml": "^0.14.0",
-		"@okfit/core": "0.2.0",
-		"@okfit/profiles": "0.2.0",
+		"@okfit/core": "0.3.0",
+		"@okfit/engine": "0.2.0",
+		"@okfit/profiles": "0.3.0",
 		"effect": "4.0.0-rc.112"
 	},
 	"engines": {

package/render/context.js

@@ -1,83 +1,4 @@
-import { Schema } from "effect";
-
 //#region src/render/context.ts
-/** One `types[]` entry (M-15). @public */
-const ContextType = Schema.Struct({
-	name: Schema.String,
-	description: Schema.NullOr(Schema.String),
-	guidance: Schema.NullOr(Schema.String)
-});
-/** One `tags[]` entry (M-15). @public */
-const ContextTag = Schema.Struct({
-	name: Schema.String,
-	description: Schema.NullOr(Schema.String)
-});
-/**
-* M-15's envelope: schema 1, snake_case, orientation data only. Distinct
-* from `JsonEnvelope` (`render/json.ts`) — `context` never runs conformance
-* or lint checks, so there is no `diagnostics` array and no `exit_code`
-* field at all.
-*
-* Every field is `Schema.NullOr`, never `Schema.optionalKey`: a consumer
-* (the two hook scripts) reads a fixed key set and gets JSON `null` for an
-* absent value, rather than having to distinguish a missing key from a
-* null one. This is a deliberate difference from `JsonDiagnostic`'s
-* `range`, which is `optionalKey` and omitted when absent
-* (`render/json.ts:14,68`).
-*
-* `profile_requested` (final-review Important 1) is the profile name the
-* config asked for after the K-4 default rule — `resolveProjectConfig`'s
-* own `profileName` — and is `null` only when no config file was found at
-* all. `profile` keeps its original meaning (the resolved profile's name,
-* or `null` when the requested name is unknown or `"none"`). The two
-* differ exactly when a config named an unrecognised profile: `profile`
-* is `null` but `profile_requested` still names what was asked for, so a
-* consumer can tell "no profile configured" apart from "an unknown profile
-* was configured".
-*
-* @public
-*/
-const ContextEnvelope = Schema.Struct({
-	schema: Schema.Literal(1),
-	project_root: Schema.String,
-	bundle_root: Schema.String,
-	config_path: Schema.NullOr(Schema.String),
-	profile: Schema.NullOr(Schema.String),
-	profile_requested: Schema.NullOr(Schema.String),
-	index_path: Schema.String,
-	index_exists: Schema.Boolean,
-	actors: Schema.Struct({ agent: Schema.NullOr(Schema.String) }),
-	types: Schema.Array(ContextType),
-	tags: Schema.Array(ContextTag)
-});
-/**
-* Build the envelope from the merged config. `types`/`tags` sort by `name`
-* with plain code-unit comparison, never locale-dependent — the same rule
-* `render/sort.ts`'s K-17 comparator and
-* `packages/profiles/src/SoftwareProject.ts:119`'s own sort use.
-*
-* @public
-*/
-const contextEnvelope = (input) => ({
-	schema: 1,
-	project_root: input.projectRoot,
-	bundle_root: input.bundleRoot,
-	config_path: input.configPath,
-	profile: input.profile,
-	profile_requested: input.profileRequested,
-	index_path: input.indexPath,
-	index_exists: input.indexExists,
-	actors: { agent: input.config.actors?.agent ?? null },
-	types: Object.entries(input.config.types ?? {}).map(([name, decl]) => ({
-		name,
-		description: decl.description ?? null,
-		guidance: decl.guidance ?? null
-	})).toSorted((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0),
-	tags: Object.entries(input.config.tags ?? {}).map(([name, decl]) => ({
-		name,
-		description: decl.description ?? null
-	})).toSorted((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)
-});
 /**
 * The `human` format: a short header block, then one line per type and one
 * per tag. Pure; the caller pipes each line through `Console.log`.
@@ -105,4 +26,4 @@ const humanContext = (envelope) => [
 ];
 
 //#endregion
-export { ContextEnvelope, ContextTag, ContextType, contextEnvelope, humanContext };
+export { humanContext };

package/render/human.js

@@ -1,4 +1,4 @@
-import { sort } from "./sort.js";
+import { sort } from "@okfit/engine";
 
 //#region src/render/human.ts
 /** The ANSI escape character, built from its code point so the source never carries a raw control byte. */

package/render/sync.js

@@ -1,64 +1,4 @@
-import { SkipReason } from "../sync/run.js";
-import { Schema } from "effect";
-
 //#region src/render/sync.ts
-/** @public */
-const SyncModeEnvelope = Schema.Struct({
-	selected: Schema.Boolean,
-	written: Schema.Array(Schema.String),
-	unchanged: Schema.Array(Schema.String),
-	skipped: Schema.Array(Schema.Struct({
-		id: Schema.String,
-		reason: SkipReason
-	}))
-});
-/**
-* Contract §14 note 5: `schema: 1` is INFERRED, not in the design's own
-* §2 JSON example — every other envelope in this codebase
-* (`JsonEnvelope`, `VerifyEnvelope`, `ContextEnvelope`) opens with it, so
-* this one does too. `exit_code` is the literal `0`: `sync` has no
-* content tier (unlike `validate`'s `0 | 1 | 2`) and this envelope only
-* exists on the success path — a failure produces `JsonErrorEnvelope`
-* (K-22) instead, unchanged.
-*
-* @public
-*/
-const SyncEnvelope = Schema.Struct({
-	schema: Schema.Literal(1),
-	okfit_version: Schema.String,
-	root: Schema.String,
-	dry_run: Schema.Boolean,
-	exit_code: Schema.Literal(0),
-	generated: SyncModeEnvelope,
-	index: SyncModeEnvelope,
-	log: SyncModeEnvelope
-});
-const toModeEnvelope = (mode) => ({
-	selected: mode.selected,
-	written: [...mode.written],
-	unchanged: [...mode.unchanged],
-	skipped: mode.skipped.map((entry) => ({
-		id: entry.id,
-		reason: entry.reason
-	}))
-});
-/**
-* `root` alone goes through `displayRoot` at the call site
-* (`commands/sync.ts`) — `generated`/`index`/`log`'s own lists are
-* already bundle-relative and need no cwd-relativisation (contract §9.1).
-*
-* @public
-*/
-const syncEnvelope = (input) => ({
-	schema: 1,
-	okfit_version: input.okfitVersion,
-	root: input.root,
-	dry_run: input.dryRun,
-	exit_code: 0,
-	generated: toModeEnvelope(input.result.generated),
-	index: toModeEnvelope(input.result.index),
-	log: toModeEnvelope(input.result.log)
-});
 /** Contract §9.2's fixed reason-sentence table, closed over `SkipReason`. */
 const REASON_SENTENCE = {
 	untracked: "not tracked by git",
@@ -98,4 +38,4 @@ const humanSync = (result) => {
 };
 
 //#endregion
-export { SyncEnvelope, SyncModeEnvelope, humanSync, syncEnvelope };
+export { humanSync };

package/render/verify.js

@@ -1,48 +1,5 @@
-import { Schema } from "effect";
-
 //#region src/render/verify.ts
 /**
-* V-11's success envelope, schema 1, snake_case — the same convention as
-* `render/json.ts`'s `JsonEnvelope`. Identical in shape for a dry run,
-* which sets `dry_run: true` and still exits 0. There is no content tier,
-* so `exit_code` is the literal `0`; a failure produces K-22's
-* `JsonErrorEnvelope` instead, unchanged.
-*
-* @public
-*/
-const VerifyEnvelope = Schema.Struct({
-	schema: Schema.Literal(1),
-	okfit_version: Schema.String,
-	id: Schema.String,
-	path: Schema.String,
-	verified: Schema.Struct({
-		by: Schema.String,
-		at: Schema.String
-	}),
-	dry_run: Schema.Boolean,
-	exit_code: Schema.Literal(0)
-});
-/**
-* `path` is already the display form — `displayRoot(cwd, bundle.root, path)`
-* joined to the bundle-relative `concept.path` — because `LoadedConcept.path`
-* alone would print `decisions/cli-exit-codes.md`, not
-* `okf/decisions/cli-exit-codes.md` (contract §12 note 5).
-*
-* @public
-*/
-const verifyEnvelope = (input) => ({
-	schema: 1,
-	okfit_version: input.okfitVersion,
-	id: input.id,
-	path: input.path,
-	verified: {
-		by: input.by,
-		at: input.at
-	},
-	dry_run: input.dryRun,
-	exit_code: 0
-});
-/**
 * Indent every line of `fragment` two spaces for display under a
 * `would write:` header, dropping the single trailing empty line a
 * newline-terminated fragment produces on split (I3).
@@ -69,4 +26,4 @@ const humanVerify = (input) => [
 ];
 
 //#endregion
-export { VerifyEnvelope, humanVerify, verifyEnvelope };
+export { humanVerify };

package/version.js

@@ -1,14 +1,14 @@
-import { version } from "./package.js";
-
 //#region src/version.ts
 /**
-* The version string reported by `okfit --version`, read from the package's
-* own manifest (K-32) so a release can never desync from the printed
-* version. Consumed by `bin.ts` only.
+* The version string reported by `okfit --version`. `@savvy-web/bundler`
+* replaces `process.env.__PACKAGE_VERSION__` with this package's own
+* version at build time (K-32), so a release can never desync from the
+* printed version. `"0.0.0"` is the unbuilt-source fallback and reads as
+* dev mode.
 *
 * @public
 */
-const CLI_VERSION = version;
+const CLI_VERSION = "0.4.0";
 
 //#endregion
 export { CLI_VERSION };

package/config/anchor.js

@@ -1,57 +0,0 @@
-//#region src/config/anchor.ts
-/**
-* The explicit `--config` anchor rule (C-8): the parent of `.config` "if the
-* file sits in a `.config` directory, else the file's directory", with no
-* exception for a custom name. Upstream's `ConfigResolver.explicitPath`
-* reports no `dir` in its `match` by design, so this stays a hand-rolled,
-* basename-based rule rather than reading `ConfigMatch.dir` — the one
-* remaining path-tail string match in the CLI outside `init/scaffold.ts`
-* (C1-4).
-*/
-const anchorForExplicit = (configPath, path) => {
-	const parent = path.dirname(configPath);
-	return path.basename(parent) === ".config" ? path.dirname(parent) : parent;
-};
-/**
-* K-12's project root, as amended by K-58 and C1-2, in order:
-*
-* 1. `pathArg`, if given. `Argument.path` has already resolved it absolute.
-* 2. otherwise, if `--config` was given: `anchorForExplicit` applied to that
-*    path.
-* 3. otherwise, if a config was discovered by the `"project"` resolver
-*    (`ConfigResolver.upwardWalk`, named `"project"` in `layer.ts`) AND it
-*    reported a `dir`: that `dir` verbatim — it is already the ancestor
-*    `upwardWalk` anchored the match against (the parent of `.config` for a
-*    `.config/okfit.toml` candidate, the candidate's own directory
-*    otherwise), so no path-tail test is needed here any more.
-* 4. otherwise `cwd` — this covers every other resolver name (`"xdg"`,
-*    `"native"`, `"system"`) as defence in depth, a `"project"` match with no
-*    `dir` (should not happen, since `upwardWalk` always reports one), and
-*    no discovery at all.
-*
-* The CLI never probes for `.git` (K-12), even though
-* `ConfigResolver.gitRoot` exists.
-*
-* @public
-*/
-const resolveProjectRoot = (input) => {
-	if (input.pathArg._tag === "Some") return input.pathArg.value;
-	if (input.explicitConfigPath._tag === "Some") return anchorForExplicit(input.explicitConfigPath.value, input.path);
-	if (input.discovered._tag === "Some") {
-		const discovered = input.discovered.value;
-		if (discovered.resolver === "project" && discovered.dir !== void 0) return discovered.dir;
-	}
-	return input.cwd;
-};
-/**
-* `<project root>/<bundle.path>`, absolute (K-2). `config` is the MERGED
-* config, so `bundle.path` is `OkfitConfig.DEFAULTS.bundle.path` (`"okf"`)
-* unless a file or profile overrode it. The bundle root is never what
-* `[path]` names.
-*
-* @public
-*/
-const resolveBundleRoot = (projectRoot, config, path) => path.resolve(projectRoot, config.bundle?.path ?? "okf");
-
-//#endregion
-export { resolveBundleRoot, resolveProjectRoot };

package/config/layer.js

@@ -1,129 +0,0 @@
-import { ConfigMalformedError, ConfigPathNotFoundError } from "../errors.js";
-import { Cause, Effect, FileSystem, Option, Result } from "effect";
-import { AppConfig } from "@effected/app";
-import { ConfigCodecError, ConfigResolver, ConfigValidationError, MergeStrategy, TomlCodec } from "@effected/config-file";
-import { OkfitConfig, OkfitConfigFile } from "@okfit/core";
-
-//#region src/config/layer.ts
-/**
-* The `OkfitConfigFile` layer for one invocation (K-9 to K-11, K-57, C-6),
-* now one `AppConfig.layer(OkfitConfigFile, ...)` call in both branches; only
-* the chain options vary:
-*
-* - `explicitConfigPath` is `Some`: `resolvers: [ConfigResolver.explicitPath(path)]`
-*   and `xdg: false` — K-10's "only that path" rule, so the chain is exactly
-*   one resolver and no `systemEtc` tier is added either.
-* - `explicitConfigPath` is `None`: `resolvers: [ConfigResolver.upwardWalk({ filenames, ... })]`
-*   carrying C-1's three per-directory candidates (`.okfit.toml`,
-*   `okfit.toml`, `.config/okfit.toml`, directory-major so a child's later
-*   candidate beats a parent's earlier one — C-2's ascent to the filesystem
-*   root is `upwardWalk`'s own default with no `stopAt`), named `"project"`
-*   so `resolve.ts`/`anchor.ts` can identify it without string-matching a
-*   path tail. `systemEtc` is C-5's `/etc` tier, present unless
-*   `systemConfigDir` overrides its root (tests only — no production call
-*   site sets it). `xdg` and `native` stay on their defaults (C-4), which is
-*   what puts personal defaults at `$XDG_CONFIG_HOME/okfit/config.toml` and
-*   the native probe behind it.
-*
-* `filename: "config.toml"` is the same in both branches — it is the XDG/
-* native/system tiers' filename, unrelated to the C-1 project names above.
-* `defaultPath` is `AppConfig.layer`'s own `XdgConfig.savePath(filename)`, so
-* `save`/`update` do not fail with `ConfigDefaultPathMissingError`; nothing
-* here sets it explicitly any more.
-*
-* `discoveryCwd` is `[path]` when given, else `process.cwd()` (K-2), passed
-* straight through as `upwardWalk`'s own `cwd` so nothing in this module
-* reads the process.
-*
-* `App.layer`, `AppStore` and `AppCache` appear nowhere, so no
-* `store.db`/`cache.db` is ever created (K-9).
-*
-* @public
-*/
-const buildConfigLayer = (options) => Option.isSome(options.explicitConfigPath) ? AppConfig.layer(OkfitConfigFile, {
-	filename: "config.toml",
-	schema: OkfitConfig,
-	codec: TomlCodec,
-	strategy: MergeStrategy.firstMatch(),
-	resolvers: [ConfigResolver.explicitPath(options.explicitConfigPath.value)],
-	xdg: false
-}) : AppConfig.layer(OkfitConfigFile, {
-	filename: "config.toml",
-	schema: OkfitConfig,
-	codec: TomlCodec,
-	strategy: MergeStrategy.firstMatch(),
-	resolvers: [ConfigResolver.upwardWalk({
-		filenames: [
-			".okfit.toml",
-			"okfit.toml",
-			".config/okfit.toml"
-		],
-		cwd: options.discoveryCwd,
-		name: "project"
-	})],
-	systemEtc: options.systemConfigDir === void 0 ? true : { dir: options.systemConfigDir }
-});
-/**
-* The K-1 pre-flight and the provide, in that order and in one place: stat
-* `explicitConfigPath` with `FileSystem.exists` and fail with
-* `ConfigPathNotFoundError` BEFORE `buildConfigLayer` is called at all. This
-* is why the CLI does not use `Command.provide(cmd, (input) => layer)`,
-* which would construct the layer first (Judge notes 9) — here the stat
-* runs as the first step of one `Effect.gen`, and `buildConfigLayer` is only
-* reached, and only then actually run, on the step after it.
-*
-* `FileSystem.FileSystem.exists` is `(path: string) => Effect.Effect<boolean, PlatformError>`
-* (`EF/FileSystem.ts:143-145`), not infallible, so
-* `PlatformError.PlatformError` joins the error channel here (decision 7):
-* an unusual stat failure (e.g. a permission error on a parent directory)
-* renders through `renderFailure`'s catch-all rule rather than being
-* uncatchable by the type checker.
-*
-* K-46/K-63 fix: a `ConfigCodecError`/`ConfigValidationError` from
-* `buildConfigLayer`'s provided layer is wrapped into `ConfigMalformedError`
-* whenever the failing path is known, so `renderFailure` can name it:
-*
-* - `ConfigCodecError` now carries its own `path: string | undefined`
-*   (config-file 0.7.0, `ConfigFile.discover` re-raises with `path` attached
-*   at every site that fed the codec a path it resolved) — used when
-*   present, so a malformed file found during DISCOVERY (no `--config`) now
-*   also wraps into `ConfigMalformedError` naming the candidate that failed,
-*   closing the K-63 gap. It falls back to `explicitConfigPath` only when
-*   the library's own `path` is `undefined` and `--config` was given; only
-*   when neither is known does the cause pass through unwrapped.
-* - `ConfigValidationError` carries its own `path: Option<string>` — used
-*   when present (either branch), falling back to `explicitConfigPath` when
-*   the library's own `path` is `None` and `--config` was given.
-*
-* @public
-*/
-const provideConfig = (options) => (effect) => Effect.gen(function* () {
-	if (Option.isSome(options.explicitConfigPath)) {
-		const path = options.explicitConfigPath.value;
-		if (!(yield* (yield* FileSystem.FileSystem).exists(path))) return yield* Effect.fail(new ConfigPathNotFoundError({ path }));
-	}
-	return yield* effect.pipe(Effect.provide(buildConfigLayer(options)), Effect.catchCause((cause) => {
-		const found = Cause.findFail(cause);
-		if (Result.isSuccess(found)) {
-			const error = found.success.error;
-			if (error instanceof ConfigCodecError) {
-				const path = error.path !== void 0 ? error.path : Option.isSome(options.explicitConfigPath) ? options.explicitConfigPath.value : void 0;
-				if (path !== void 0) return Effect.fail(new ConfigMalformedError({
-					path,
-					cause: error
-				}));
-			}
-			if (error instanceof ConfigValidationError) {
-				const path = Option.isSome(options.explicitConfigPath) ? options.explicitConfigPath : error.path;
-				if (Option.isSome(path)) return Effect.fail(new ConfigMalformedError({
-					path: path.value,
-					cause: error
-				}));
-			}
-		}
-		return Effect.failCause(cause);
-	}));
-});
-
-//#endregion
-export { buildConfigLayer, provideConfig };

package/config/resolve.js

@@ -1,67 +0,0 @@
-import { resolveBundleRoot, resolveProjectRoot } from "./anchor.js";
-import { Console, Effect, Option, Path } from "effect";
-import { OKF_SPEC_VERSION, OkfitConfig, OkfitConfigFile } from "@okfit/core";
-import { Profiles } from "@okfit/profiles";
-
-//#region src/config/resolve.ts
-/**
-* `OkfitConfig.DEFAULTS.bundle.profile` is `"software-project"` at runtime
-* (the frozen literal always sets it), but `bundle` and `profile` are both
-* `optionalKey` in the schema, so the type checker sees `string | undefined`
-* two levels deep. The `?? "software-project"` fallback here is unreachable
-* in practice; it exists only to satisfy `noUncheckedIndexedAccess`-style
-* strictness without a non-null assertion. Formerly duplicated identically
-* in `commands/validate.ts` and `commands/context.ts`; this is its one home
-* now that both commands delegate to {@link resolveProjectConfig}.
-*
-* @public
-*/
-const DEFAULT_PROFILE_NAME = OkfitConfig.DEFAULTS.bundle?.profile ?? "software-project";
-/**
-* The config-resolution step byte-identical between `validate` and
-* `context`'s handlers (A2 review finding): discover, pick `sources[0]`,
-* default `{ extensions: {} }`, resolve the profile name and the K-4
-* unknown-profile warning, merge `DEFAULTS < profile < file` (D-28), warn on
-* an `okf_version` mismatch (K-15), then resolve the project and bundle
-* roots (K-12). Every message string and the merge order are unchanged from
-* the two commands' former inline copies.
-*
-* @public
-*/
-const resolveProjectConfig = (input) => Effect.gen(function* () {
-	const path = yield* Path.Path;
-	const discoveredSource = (yield* (yield* OkfitConfigFile).discover)[0];
-	const fileConfig = discoveredSource === void 0 ? { extensions: {} } : discoveredSource.value;
-	const profileName = fileConfig.bundle?.profile ?? DEFAULT_PROFILE_NAME;
-	const profile = profileName === "none" ? Option.none() : Profiles.get(profileName);
-	if (profileName !== "none" && Option.isNone(profile)) yield* Console.error(`warning: unknown profile "${profileName}"; continuing with defaults`);
-	const base = Option.match(profile, {
-		onNone: () => OkfitConfig.DEFAULTS,
-		onSome: (p) => OkfitConfig.merge(OkfitConfig.DEFAULTS, p.config)
-	});
-	const merged = OkfitConfig.merge(base, fileConfig);
-	if (merged.okf_version !== void 0 && merged.okf_version !== OKF_SPEC_VERSION) yield* Console.error(`warning: okf_version "${merged.okf_version}" does not match this okfit's spec version "${OKF_SPEC_VERSION}"; continuing`);
-	const discovered = discoveredSource === void 0 ? Option.none() : Option.some({
-		path: discoveredSource.path,
-		resolver: discoveredSource.resolver,
-		...discoveredSource.match?.dir !== void 0 ? { dir: discoveredSource.match.dir } : {}
-	});
-	const projectRoot = resolveProjectRoot({
-		pathArg: input.pathArg,
-		explicitConfigPath: input.explicitConfigPath,
-		discovered,
-		cwd: input.cwd,
-		path
-	});
-	return {
-		projectRoot,
-		bundleRoot: resolveBundleRoot(projectRoot, merged, path),
-		config: merged,
-		profile,
-		profileName,
-		discovered
-	};
-});
-
-//#endregion
-export { DEFAULT_PROFILE_NAME, resolveProjectConfig };

package/context/run.js

@@ -1,35 +0,0 @@
-import { Effect, FileSystem, Path } from "effect";
-
-//#region src/context/run.ts
-/**
-* The whole of `context`'s filesystem work: join `index.md` onto the bundle
-* root and stat it. Loading a bundle and running conformance/lint checks
-* over it never happen here — that is what makes `context` cheap enough
-* for a hook to run on every session start and every in-bundle write
-* (M-15).
-*
-* `"index.md"` is a literal here, not read from the profile's layout: the
-* spec fixes the reserved filename regardless of profile, and a
-* profile-less merge (`profile = "none"`) has no layout to read from at
-* all — `context` behaves identically with and without a profile.
-*
-* `exists` is `(path) => Effect.Effect<boolean, PlatformError>`, so an
-* unreadable parent directory would otherwise fail the command; here it is
-* absorbed to `false`, because "the hook could not stat index.md" and
-* "index.md is not there" are the same fact from a consumer's point of
-* view.
-*
-* @public
-*/
-const runContext = (options) => Effect.gen(function* () {
-	const path = yield* Path.Path;
-	const fs = yield* FileSystem.FileSystem;
-	const indexPath = path.join(options.bundleRoot, "index.md");
-	return {
-		indexPath,
-		indexExists: yield* fs.exists(indexPath).pipe(Effect.orElseSucceed(() => false))
-	};
-});
-
-//#endregion
-export { runContext };