dorfl 0.0.0 → 0.1.0

package/dist/work-layout.js

@@ -0,0 +1,217 @@
+import { join } from 'node:path';
+/**
+ * The **work-layout** module: the SOLE source of every `work/...` path string,
+ * folder-name union/array, the item-scan predicate, and the prefix-task helpers
+ * used across `src/`.
+ *
+ * This is Phase 0 of the `folder-taxonomy-reorg-and-rename` prd — the de-risking
+ * checkpoint. EVERY raw work-path literal (`join(cwd, 'work', ...)`, `'work/<folder>'`,
+ * `'work/<folder>/'.length` prefix-tasks) and EVERY folder-name union/array that
+ * used to be scattered across ~70 files now routes through here. The NAMES are
+ * byte-identical to today (no rename, no behaviour change); only the SOURCE of the
+ * string has moved into this one module.
+ *
+ * The whole point of the seam: the LATER rename tasks flip the VALUES in
+ * {@link WORK_FOLDER_NAME} (and `git mv` the on-disk folders) and NOTHING ELSE.
+ * Call sites reference folders by their SYMBOLIC key (`'tasks-ready'`,
+ * `'specs-ready'`, …), never by a raw string, so a folder-VALUE flip never
+ * re-touches a single call site (a KEY rename, e.g. the prd→spec cutover below,
+ * is a mechanical relabel of the key literal at each site — behaviour-preserving).
+ *
+ * Domain note (crown-jewel invariant): a `work/` tree is a set of governance
+ * folders where "status IS the folder" — a CAS `git mv` between durable folders is
+ * the conflict-safe state machine. This module owns the folder NAMES that literally
+ * are that state machine, so it is deliberately the one place a careless rename can
+ * touch.
+ *
+ * The transient states (`in-progress`/`needs-attention`/`tasking`/`advancing`) are
+ * NOT folders — they are per-item lock-ref state (see `item-lock.ts`). A stray
+ * `in-progress` literal still referenced by some legacy/recovery readers routes
+ * through this module like any other folder, but is NOT part of the durable
+ * folder-as-status set.
+ */
+/**
+ * The repo-relative root of the `work/` governance tree. The single literal `'work'`
+ * the whole package shares — every path builder below is rooted here.
+ */
+export const WORK_ROOT = 'work';
+/**
+ * Every work-folder SYMBOLIC KEY → its current on-disk folder NAME (byte-identical
+ * to today). This is the ONE place a folder name lives; the later taxonomy rename is
+ * a value-only flip of the right-hand side here.
+ *
+ * Folder kinds (kept here as a single registry, but their distinct roles matter):
+ *   - TASK lifecycle, the `tasks/` Kanban board: `tasks/backlog` (staging, key
+ *     `tasks-backlog`) → `tasks/ready` (the agent pool, key `tasks-ready`) →
+ *     `tasks/done` / `tasks/cancelled` (the PER-REGIME won't-proceed terminal, key
+ *     `cancelled`).
+ *   - SPEC lifecycle, the `specs/` regime: `specs/proposed` (staging, key
+ *     `specs-proposed`) → `specs/ready` (auto-task pool, key `specs-ready`) →
+ *     `specs/tasked` (tasked, resting, key `specs-tasked`) / `specs/dropped`
+ *     (the PER-REGIME won't-proceed terminal, key `specs-dropped`).
+ *   - The PER-REGIME won't-proceed terminals (`tasks/cancelled` + `specs/dropped`)
+ *     replace the previous shared top-level `work/dropped/`: a dropped task and a
+ *     dropped spec sharing a slug used to COLLIDE on one bare-slug
+ *     `work/dropped/<slug>.md`; namespacing each regime's terminal removes the
+ *     collision. A dropped OBSERVATION needs no terminal — notes leave by deletion.
+ *   - Capture buckets under the `notes/` umbrella (do NOT flow; leave by deletion):
+ *     `notes/observations` / `notes/ideas` / `notes/findings`.
+ *   - Top-level surfaces: `questions` (the "what needs me?" queue), `protocol`
+ *     (propagated protocol docs). NEITHER is folded under an umbrella.
+ *   - The stray transient `in-progress` still referenced by legacy/recovery readers
+ *     and `needs-attention` (both are really lock-ref state, NOT durable folders;
+ *     routed here only so no reader hand-writes the literal).
+ *
+ * NOTE on the prd→spec vocabulary cutover
+ * (`rename-spec-work-layout-and-folders`, migrate-batch 1 of
+ * `prd-to-spec-vocabulary-cutover-and-migration-command`): the spec-regime KEYS
+ * below now read in the `spec` vocabulary (`specs-proposed`/`specs-ready`/
+ * `specs-tasked`/`specs-dropped`) AND their VALUES flip to `work/specs/*` in
+ * lockstep with the on-disk `git mv work/prds/* → work/specs/*`. Unlike the earlier
+ * key-only relabel, this batch moves the folders too, so the KEY and VALUE change
+ * together and the self-renaming-folder guard stays green. The KEY rename is a
+ * mechanical relabel of the key literal at each call site (behaviour-preserving);
+ * the frontmatter `prd:` field (a DATA alias the migration command converts) is the
+ * one deliberate survivor; the `--specs-land-in` flag/`specsLandIn` config + the
+ * `Spec*` symbols were completed by the later batches + the contract task. The
+ * folder-as-status invariant is unchanged.
+ */
+export const WORK_FOLDER_NAME = {
+    'tasks-backlog': 'tasks/backlog',
+    'tasks-ready': 'tasks/ready',
+    'in-progress': 'in-progress',
+    'needs-attention': 'needs-attention',
+    done: 'tasks/done',
+    cancelled: 'tasks/cancelled',
+    'specs-proposed': 'specs/proposed',
+    'specs-ready': 'specs/ready',
+    'specs-tasked': 'specs/tasked',
+    'specs-dropped': 'specs/dropped',
+    observations: 'notes/observations',
+    ideas: 'notes/ideas',
+    findings: 'notes/findings',
+    questions: 'questions',
+    protocol: 'protocol',
+};
+/**
+ * Resolve a folder's current on-disk NAME from its symbolic key. The ONE accessor
+ * every other folder-name lookup derives from, so the rename flips it in lockstep.
+ */
+export function workFolderName(folder) {
+    return WORK_FOLDER_NAME[folder];
+}
+/**
+ * Absolute path of a work folder under a repo/cwd root:
+ * `<root>/work/<folder-name>`. Replaces every `join(cwd, 'work', '<folder>')` and
+ * `join(repoPath, 'work', folder)` call site.
+ */
+export function workFolderPath(root, folder) {
+    return join(root, WORK_ROOT, workFolderName(folder));
+}
+/**
+ * Absolute path of a single item's `.md` file in a work folder:
+ * `<root>/work/<folder-name>/<slug>.md`. Replaces every
+ * `join(cwd, 'work', folder, `${slug}.md`)` call site. `slug` is the bare slug
+ * (the `.md` suffix is appended here).
+ */
+export function workItemPath(root, folder, slug) {
+    return join(root, WORK_ROOT, workFolderName(folder), `${slug}.md`);
+}
+/**
+ * REPO-RELATIVE path of a work folder: `work/<folder-name>` (no trailing slash, no
+ * root). The form used for `git mv` / `git`-relative paths and the staging/pool dir
+ * constants (`STAGED_TASKS_DIR`, etc.). Replaces raw `'work/<folder>'` literals.
+ */
+export function workFolderRel(folder) {
+    return `${WORK_ROOT}/${workFolderName(folder)}`;
+}
+/**
+ * REPO-RELATIVE path of a single item file: `work/<folder-name>/<basename>`. The
+ * `basename` is a full filename (caller decides whether it carries `.md`), matching
+ * the existing `join('work', folder, '<file>')` call sites that pass either a
+ * `${slug}.md` or a pre-suffixed name.
+ */
+export function workItemRel(folder, basename) {
+    return `${WORK_ROOT}/${workFolderName(folder)}/${basename}`;
+}
+/**
+ * The REPO-RELATIVE folder PREFIX (WITH trailing slash): `work/<folder-name>/`. The
+ * form a reader matches with `startsWith(...)` and tasks off to recover a filename
+ * (see {@link stripWorkFolderPrefix}). Replaces hand-written `'work/<folder>/'`
+ * literals and their `.length` prefix-tasks.
+ */
+export function workFolderPrefix(folder) {
+    return `${workFolderRel(folder)}/`;
+}
+/**
+ * Recover the filename portion of a repo-relative path that lives DIRECTLY under a
+ * work folder, by stripping its `work/<folder-name>/` prefix. Replaces the
+ * hand-written `path.slice('work/<folder>/'.length)` prefix-task. Returns
+ * `undefined` when `path` is not under that folder, so callers that already
+ * `startsWith`-guarded keep their exact behaviour (and callers that did not can
+ * branch on `undefined` instead of tasking a wrong length).
+ */
+export function stripWorkFolderPrefix(path, folder) {
+    const prefix = workFolderPrefix(folder);
+    return path.startsWith(prefix) ? path.slice(prefix.length) : undefined;
+}
+/**
+ * The ITEM-SCAN predicate: does this directory entry NAME count as a `work/` item?
+ * Defined ONCE here so no reader re-implements the `.md` filter. Case-insensitive
+ * on the extension, matching every existing `name.toLowerCase().endsWith('.md')`
+ * call site verbatim.
+ */
+export function isWorkItemFile(name) {
+    return name.toLowerCase().endsWith('.md');
+}
+// --- Folder-name unions / arrays (one definition, derived from the registry) --
+/**
+ * The TASK-RESOLUTION folders `resolveTask` (prompt.ts) walks, in precedence
+ * order: `in-progress` over `tasks-ready`, with `done` appended only behind the
+ * stranded-continue gate. Order is load-bearing — kept exactly as the original
+ * union/array. (`tasks-backlog` is NOT in this DEFAULT order: it is appended at
+ * the LOWEST priority ONLY behind the explicit `--allow-backlog` flag, prd
+ * `do-allow-backlog-drive-staged-tasks-without-promotion` — see
+ * {@link TaskResolutionFolder}.)
+ */
+export const TASK_RESOLUTION_FOLDERS = [
+    'in-progress',
+    'tasks-ready',
+    'done',
+];
+/**
+ * The task LIFECYCLE folders a `task:<slug>` / lone-task `issue:` can reside
+ * in (spec-complete.ts + close-job.ts `TASK_FOLDERS`): `tasks-ready`, `in-progress`,
+ * `needs-attention`, `done`.
+ */
+export const TASK_LIFECYCLE_FOLDERS = [
+    'tasks-ready',
+    'in-progress',
+    'needs-attention',
+    'done',
+];
+/**
+ * The DURABLE task-status folders the ledger lint / integration core treat as the
+ * one-slug-one-folder state machine: `tasks-ready`, `done`, `cancelled`
+ * (ledger-lint.ts + integration-core.ts `LEDGER_STATUS_FOLDERS`). The transient
+ * `in-progress`/`needs-attention`/`tasking` are NOT here (they are lock-ref state).
+ * `cancelled` is the task regime's won't-proceed terminal (the per-regime split
+ * of the previous shared `dropped/`); the spec regime's terminal `specs-dropped`
+ * is NOT here (this set is the TASK board's state machine, keyed by `tasks/`-slug,
+ * and a spec never co-resides with a task on the tasks board).
+ */
+export const LEDGER_STATUS_FOLDERS = [
+    'tasks-ready',
+    'done',
+    'cancelled',
+];
+/**
+ * The SPEC-lifecycle folders an `issue:`-bearing spec / a tasked spec can reside
+ * in: `specs-ready` (source / pool), `specs-tasked` (tasked, resting) —
+ * close-job.ts `SPEC_FOLDERS`.
+ */
+export const SPEC_FOLDERS = [
+    'specs-ready',
+    'specs-tasked',
+];
+//# sourceMappingURL=work-layout.js.map

package/dist/work-layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-layout.js","sourceRoot":"","sources":["../src/work-layout.ts"],"names":[],"mappings":"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"}

package/dist/work-on.d.ts

@@ -0,0 +1,154 @@
+import { encodeRepoKey } from './repo-mirror.js';
+import { type Config } from './config.js';
+import type { InteractiveLauncher } from './harness.js';
+/**
+ * `dorfl work-on` — the HUMAN command to claim a task and create an
+ * isolated **worktree in a human-friendly location**, so a person can open their
+ * editor and work several tasks in parallel without juggling branches in one
+ * checkout. It is the human counterpart to the runner's job worktrees
+ * (`workspace.ts`): it is NEVER used by agents, so it never carries the human's
+ * secrets into an agent context (see `--copy`).
+ *
+ * Two invocation forms — the ONLY intended difference between them is **where the
+ * worktree's files live**; the claim, the integration semantics, and the
+ * starting commit are IDENTICAL:
+ *
+ *   work-on <slug>                in-repo: the arbiter remote/URL is inferred from
+ *                                 the current repo; the claim runs in that repo.
+ *   work-on --remote <r> <slug>   remote: ensure a hub mirror for <r> (creating
+ *                                 it via repo-mirror if absent, exactly like
+ *                                 agents do), then claim against it from a
+ *                                 throwaway worktree. The remote target is a FLAG
+ *                                 (consistent with `do --remote`), not positional.
+ *
+ * BOTH forms: claim the slug, then ALWAYS `git fetch` and branch the worktree off
+ * the **freshly-fetched `<arbiter>/main`** — never a possibly-stale local ref.
+ * THIS GUARANTEE is what makes the two forms equivalent: the same slug yields
+ * equivalent work either way (same starting commit).
+ *
+ * The worktree lives under the configured `humanWorktreesDir`
+ * (`<dir>/<key>/<slug>/` on branch `work/<slug>`) — prompted + saved on first use,
+ * with a sensible suggestion but no silent default, and NEVER under
+ * `~/.dorfl/` (that is the agents' area; `work-on` is human-only).
+ *
+ * A binary cannot `cd` its parent shell, so on success it prints the worktree path
+ * + a `cd` hint; `--print-dir` emits the path ONLY (stdout) so the human can
+ * install a shell function that actually cd's them:
+ *
+ *   work-on() { cd "$(dorfl work-on "$@" --print-dir)"; }
+ */
+/** The semantic outcome of a `work-on` invocation. */
+export type WorkOnOutcome = 'created' | 'refused' | 'lost' | 'contended' | 'usage-error';
+export interface WorkOnOptions {
+    /** The slug to work on (`work/backlog/<slug>.md`). Required. */
+    slug: string;
+    /**
+     * Remote mode: the remote spec/URL to mirror via `repo-mirror`. When given,
+     * `work-on --remote <r> <slug>` ensures a hub mirror (creating it if absent)
+     * and claims against it. When omitted, in-repo mode: the arbiter is inferred
+     * from `cwd`.
+     */
+    remote?: string;
+    /** The current working directory (in-repo mode resolves the arbiter from it). */
+    cwd: string;
+    /**
+     * Name of the arbiter git remote in `cwd` (in-repo mode only). Defaults to
+     * `origin`. Ignored in remote mode (the mirror's own `origin` is used).
+     */
+    arbiter?: string;
+    /**
+     * Override the readiness guard (`--ignore-not-ready`): claim despite
+     * an unmet `blockedBy`, and silence the `needsAnswers` warning. Forwarded to
+     * the claim CAS's human-path guard.
+     */
+    override?: boolean;
+    /**
+     * Comma-separated glob-free filenames (gitignored, untracked files like
+     * `.env.local,.env`) to COPY into the new worktree so the project is runnable.
+     * Copy, not symlink (tooling-safe). Source = the current repo in-repo mode; in
+     * remote mode there is no implicit source, so `--copy` REQUIRES `copyFrom`.
+     */
+    copy?: string;
+    /**
+     * The explicit source dir for `--copy` in remote mode (`--copy-from <path>`).
+     * Required when `copy` is set in remote mode; ignored otherwise.
+     */
+    copyFrom?: string;
+    /** The execution working area for hub mirrors (config `workspacesDir`). */
+    workspacesDir?: string;
+    /**
+     * The human worktree root (config `humanWorktreesDir`). When already
+     * configured this is used directly; when undefined, `promptForRoot` is invoked
+     * to obtain + SAVE it (first-use prompt). Tests pass it directly to avoid TTY.
+     */
+    humanWorktreesDir?: string;
+    /**
+     * First-use prompt for the human worktree root. Called only when
+     * `humanWorktreesDir` is undefined (in config + options). Receives a sensible
+     * SUGGESTION; returns the chosen absolute path (or '' to abort). The CLI wires
+     * a readline prompt; tests inject a stub.
+     */
+    promptForRoot?: (suggestion: string) => Promise<string> | string;
+    /**
+     * Persist a newly-prompted `humanWorktreesDir`. The CLI wires this to
+     * `saveConfig` at `configPath`; tests can inject a spy or a no-op.
+     */
+    saveRoot?: (dir: string) => void;
+    /**
+     * `--agent` (task `agent-interactive-launch`): after the human worktree is
+     * created, launch the configured harness INTERACTIVELY in THAT worktree — a
+     * foreground session the human drives (no prepared prompt). Injected as a thin
+     * launcher so `work-on.ts` stays decoupled from `createHarness`: the CLI wires
+     * it to the resolved harness's `launchInteractive` (model/session resolved
+     * there). Omitted ⇒ work-on creates the worktree and prints the cd hint (its
+     * historical behaviour). It is NOT a tracked job (decision #3): no job record,
+     * no gate — after exit the human drives `complete`/`requeue`.
+     */
+    launchInteractive?: InteractiveLauncher;
+    /** Environment for child git processes (identity etc.). */
+    env?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress + the security notice (stderr). */
+    note?: (message: string) => void;
+}
+export interface WorkOnResult {
+    exitCode: 0 | 1 | 2 | 3;
+    outcome: WorkOnOutcome;
+    /** Absolute path to the created worktree (only on success). */
+    dir?: string;
+    /** The work branch checked out there (`work/<slug>`). */
+    branch?: string;
+    /** The resolved arbiter URL the worktree branches from. */
+    arbiterUrl?: string;
+    /** The starting commit (freshly-fetched `<arbiter>/main`) the worktree is cut from. */
+    startCommit?: string;
+    /** Files copied in via `--copy` (basenames), in order. */
+    copied?: string[];
+    /** Human-readable summary of the terminal condition. */
+    message: string;
+}
+/**
+ * Run the `work-on` ritual. Never throws for the expected lost/contended/refused
+ * cases — those are returned with the appropriate exit code and NO worktree.
+ * Usage/environment problems surface as exit 1.
+ */
+export declare function performWorkOn(options: WorkOnOptions): Promise<WorkOnResult>;
+/**
+ * A sensible SUGGESTION for the human worktree root. Deliberately uses a name
+ * (`~/worktrees`) that does NOT share a prefix with the usual code dir
+ * (`~/dev/...`), so shell tab-completion on the code dir never collides with it.
+ * This is only a suggestion — there is no silent default; the human confirms.
+ */
+export declare function suggestHumanWorktreesDir(): string;
+/**
+ * Resolve `humanWorktreesDir` + `configPath` for the CLI: read config from
+ * `configPath` and surface its `humanWorktreesDir` (undefined ⇒ first use). The
+ * CLI wires the prompt/save around this; kept here so the wiring is testable.
+ */
+export declare function loadHumanWorktreesDir(configPath?: string): {
+    dir: string | undefined;
+    config: Config;
+};
+/** Save a chosen `humanWorktreesDir` back to `configPath`, preserving the rest. */
+export declare function persistHumanWorktreesDir(dir: string, configPath?: string): void;
+export { encodeRepoKey };
+//# sourceMappingURL=work-on.d.ts.map

package/dist/work-on.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-on.d.ts","sourceRoot":"","sources":["../src/work-on.ts"],"names":[],"mappings":"AAKA,OAAO,EACN,aAAa,EAIb,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAIN,KAAK,MAAM,EACX,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,cAAc,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,sDAAsD;AACtD,MAAM,MAAM,aAAa,GACtB,SAAS,GACT,SAAS,GACT,MAAM,GACN,WAAW,GACX,aAAa,CAAC;AAEjB,MAAM,WAAW,aAAa;IAC7B,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iFAAiF;IACjF,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2EAA2E;IAC3E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;IACjE;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC;;;;;;;;;OASG;IACH,iBAAiB,CAAC,EAAE,mBAAmB,CAAC;IACxC,2DAA2D;IAC3D,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,uEAAuE;IACvE,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,YAAY;IAC5B,QAAQ,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACxB,OAAO,EAAE,aAAa,CAAC;IACvB,+DAA+D;IAC/D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uFAAuF;IACvF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;CAChB;AAOD;;;;GAIG;AACH,wBAAsB,aAAa,CAClC,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,CAAC,CAQvB;AA6YD;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAsDD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACpC,UAAU,GAAE,MAA4B,GACtC;IACF,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CACf,CAGA;AAED,mFAAmF;AACnF,wBAAgB,wBAAwB,CACvC,GAAG,EAAE,MAAM,EACX,UAAU,GAAE,MAA4B,GACtC,IAAI,CAGN;AAGD,OAAO,EAAC,aAAa,EAAC,CAAC"}