halfcycle 0.3.7

package/dist/setup/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../src/setup/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAUH;iFACiF;AACjF,MAAM,MAAM,UAAU,GAClB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACvE;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpF,+DAA+D;AAC/D,MAAM,WAAW,cAAc;IAC7B,uFAAuF;IACvF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;CAC7B;AAED,iEAAiE;AACjE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,oCAAoC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;+CAC2C;IAC3C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAC;IAC7C,QAAQ,CAAC,SAAS,EAAE,SAAS,YAAY,EAAE,CAAC;CAC7C;AAED;oCACoC;AACpC,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAEvD;AA0JD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAuFtE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,YAAY,EAAE,CAG/E;AAED,mFAAmF;AACnF,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAI/D"}

package/dist/setup/engagement.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The confirm phase's output — the engagement record, the tracker choice, and the
+ * halt (feature `halfcycle-setup`, criteria 2 and 7; task T-17).
+ *
+ * **The halt is the load-bearing part.** `ENGAGEMENT.md` is a record of decisions,
+ * and a record of an unasked question is a fabrication — so the command does not
+ * proceed with an unanswered decision. There is no "we'll assume" and no default
+ * that skips the question. `buildEngagementRecord` returns a HALT rather than a
+ * document, and the halt writes nothing at all.
+ *
+ * **What a halt must not report, and why it is stated here rather than left to the
+ * caller.** A halt is precisely the case where the gate was NOT conducted, so the
+ * report it produces asserts only that the step was attempted and could not
+ * complete. It emits nothing. Reporting a failing gate would record an outcome for
+ * a question nobody asked — into a store with one writer, no delete path, and an
+ * upsert that may never touch a verdict — and gate precedence would then hand the
+ * step's decision to the gate tier, so a later completed run alone could no longer
+ * satisfy it. `HaltReport.emits` is therefore an empty, frozen list: the shape says
+ * what is true and nothing more.
+ *
+ * **Why the six decisions are not enumerated in this file.** Which questions an
+ * engagement settles is the method's content and has one home, upstream. This
+ * module enforces the *rule* — every decision put carries an answer AND a reason,
+ * and the caller states how many the run owes — which is what the criterion
+ * actually asserts. Encoding the list here would put method structure at rest in a
+ * shippable (INV-016's Connect surface) and would give this package a second home
+ * for something the method already owns.
+ *
+ * INV-001: this module imports only its own package's siblings.
+ */
+import type { ArtefactRow } from './manifest.js';
+/** One settled decision: what was asked, what was answered, and why. A decision
+ *  missing either half is not settled. */
+export interface Decision {
+    readonly key: string;
+    readonly question: string;
+    readonly answer: string;
+    readonly rationale: string;
+}
+/**
+ * The tracker choice — a seventh recorded value, not one of the decisions.
+ *
+ * `chosen` defaults to the flat-file backend, `alternativeOffered` is what was put
+ * beside it, and `rationale` is why. Choosing silently is the failure this shape
+ * exists to prevent: the cost of a second place to look is consistently
+ * underestimated, and a tracker nobody opens is worse than a file in the repository.
+ */
+export interface TrackerChoice {
+    readonly chosen: string;
+    readonly alternativeOffered: string;
+    readonly rationale: string;
+    /** The repository directory the choice needs, or null when the backend lives
+     *  outside the repository. */
+    readonly home: string | null;
+}
+/** The default, stated rather than assumed — with the alternative offered. */
+export declare function flatFileTrackerDefault(): TrackerChoice;
+/**
+ * What a halt reports. `emits` is empty and frozen — a halt conducts no gate, so
+ * it emits nothing, and there is no code path in this module that can add to it.
+ */
+export interface HaltReport {
+    readonly halted: true;
+    /** The keys of the decisions that are not settled, in the order they were put. */
+    readonly unsettled: readonly string[];
+    /** Plain words for the developer and for the step report's failure reason. */
+    readonly reason: string;
+    /** Always empty: nothing is emitted by a step that could not be conducted. */
+    readonly emits: readonly never[];
+}
+export type EngagementOutcome = {
+    readonly ok: true;
+    readonly document: string;
+    readonly rows: readonly ArtefactRow[];
+} | {
+    readonly ok: false;
+    readonly halt: HaltReport;
+};
+export interface EngagementInput {
+    /** The decisions this run put, each with its answer and its reason. */
+    readonly decisions: readonly Decision[];
+    /** How many decisions the run owes. Supplied by the caller — the method owns
+     *  which questions those are; this module owns that none of them is skipped. */
+    readonly requiredDecisions: number;
+    readonly tracker: TrackerChoice;
+    /** A name for the engagement, used in the document's title. */
+    readonly projectName: string;
+    /** When the decisions were settled, ISO-8601. */
+    readonly settledAt: string;
+}
+/**
+ * Build the engagement record's manifest rows, or halt.
+ *
+ * Halts when fewer decisions were put than the run owes, or when any decision put
+ * is missing its answer or its reason. A halt returns NO rows, so nothing is
+ * written and no partial record is left behind.
+ */
+export declare function buildEngagementRecord(input: EngagementInput): EngagementOutcome;
+//# sourceMappingURL=engagement.d.ts.map

package/dist/setup/engagement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engagement.d.ts","sourceRoot":"","sources":["../../src/setup/engagement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAOjD;0CAC0C;AAC1C,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;kCAC8B;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,8EAA8E;AAC9E,wBAAgB,sBAAsB,IAAI,aAAa,CAStD;AAMD;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,kFAAkF;IAClF,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,SAAS,KAAK,EAAE,CAAC;CAClC;AAED,MAAM,MAAM,iBAAiB,GACzB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAA;CAAE,GACvF;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC;AAWtD,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,QAAQ,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAC;IACxC;oFACgF;IAChF,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,+DAA+D;IAC/D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAgCD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,eAAe,GAAG,iBAAiB,CA6B/E"}

package/dist/setup/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The setup write path — the one mechanism a served run lands client-tree
+ * artefacts through, plus the discover and confirm halves that feed it.
+ *
+ * `manifest.ts` is the mechanism (scope §2; the design journey's Layer-2 writes are
+ * its second consumer per scope §7, driven by T-18's walk); `rows.ts` fixes the
+ * declared paths and the additive form; `discovery.ts` is the anchored discover
+ * phase; `engagement.ts` is the confirm phase's record and its halt.
+ */
+export { applySetupWrites, SetupManifest } from './manifest.js';
+export type { ArtefactRow, RowOutcome, ManifestEntry, WriteReport } from './manifest.js';
+export { contextIndexRow, agentsPointerRow, layerDocumentRow, documentSectionRow, engagementRecordRow, trackerHomeRow, FLAT_FILE_TRACKER_HOME, } from './rows.js';
+export { discoverRepository, questionsToPut, renderDiscovery, renderAnchor } from './discovery.js';
+export type { DiscoveredFact, OpenQuestion, DiscoveryResult, FactAnchor } from './discovery.js';
+export { buildEngagementRecord, flatFileTrackerDefault } from './engagement.js';
+export type { Decision, TrackerChoice, EngagementInput, EngagementOutcome, HaltReport } from './engagement.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/setup/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/setup/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAChE,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEzF,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,sBAAsB,GACvB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnG,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEhG,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAChF,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,eAAe,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/setup/manifest.d.ts

@@ -0,0 +1,155 @@
+/**
+ * The write manifest — the ONE mechanism that lands client-tree artefacts during a
+ * served run (feature `halfcycle-setup`, the scope §2 write manifest; task T-17).
+ *
+ * **What this is.** A session resolving a served command executes what comes back
+ * and, where the instruction directs a write, lands it *through here*. Every row of
+ * the manifest — the union of what the served steps write — goes through one
+ * function, so the never-clobber rule, the declared-path rule and the report are
+ * stated once rather than per caller. `halfcycle-setup`'s five rows are the first
+ * consumer; the design journey's Layer-2 artefacts are the second (scope §7: one
+ * mechanism, two consumers).
+ *
+ * **The timing is the caller's, and that is deliberate.** The spec's manifest is
+ * *spread across the served steps* — `CLAUDE.md`/`AGENTS.md` and the scaffolding
+ * land at the first resolves, `ENGAGEMENT.md` and the tracker home at the last —
+ * and it is explicitly NOT a terminal write phase. This module therefore takes a
+ * batch of rows per call and is invoked once per resolve; it holds no schedule.
+ *
+ * **WHAT THIS MODULE MUST NOT BECOME, and why the API is shaped this way.** It
+ * carries no map from a step to the rows that step writes. Such a table is
+ * method structure at rest in a shippable (INV-016's Connect surface: nothing
+ * method-shaped is installed at rest; INV-001's allowlist exists to keep
+ * method-shaped values out of this package), and `stub-vocabulary-gate.test.ts`
+ * already asserts no source file here carries a step id. The instruction that
+ * directs a write arrives from the delivery service per resolve; the session turns
+ * it into rows; this module validates and applies them. Anything that would let
+ * this file answer "what does step X write?" is out of bounds.
+ *
+ * **Two rules from the spec are acceptance criteria, not implementation detail,
+ * and both are enforced here rather than by the caller:**
+ *
+ *   - **`docs/method/` is never created in a client repository (INV-016).** It is
+ *     denied POSITIVELY, not by omission: `docs/` scaffolding is a declared row,
+ *     so `docs/method/` sits *inside* an allowed prefix and a plain allowlist would
+ *     wave it through. The deny check runs first and wins, it runs on the
+ *     `posix.normalize`d path so `.` and `//` segments cannot slip past it, and it
+ *     is case-insensitive because on the default macOS filesystem `docs/METHOD/` IS
+ *     `docs/method/`.
+ *   - **Nothing pre-existing is overwritten.** A file the developer already owns is
+ *     left byte-for-byte and reported; a file that gains a section keeps every byte
+ *     it had. There is no overwrite path in this module at all. A path that is, or
+ *     sits under, a **symbolic link** is left alone and reported rather than written
+ *     through. **That guarantee is symlink-shaped and no wider:** `lstat` cannot see
+ *     a HARD link, so a hardlinked declared path still writes into the file it
+ *     shares an inode with, wherever that is. Stated rather than closed — a hardlink
+ *     into a client repository is not a shape this product creates, and the honest
+ *     boundary is worth more here than a guard that would have to stat every inode.
+ *
+ * **What the content check is, stated precisely because a wider claim was made here
+ * twice.** The module refuses content carrying any of three decidable forms of
+ * method structure — a step id, a step annotation, an anchor declaration. It is a
+ * tripwire, **not** a detector of method prose. **Measured over the population a
+ * session can actually reach — served bodies, not corpus documents — it refuses 0 of
+ * 58**, and only the step-id form fires on the wire at all — the anchor form has a
+ * latent cost there rather than a benefit. The constants' docblock
+ * carries both populations and why they differ; read it before crediting this check
+ * with anything.
+ *
+ * INV-019: the paths this module may write are exactly the five the feature spec
+ * declares — `CLAUDE.md`, `AGENTS.md`, `ENGAGEMENT.md`, `docs/tasks/` and the
+ * layer-doc scaffolding under `docs/`. All five are Zone-A client product material
+ * and clear the egress gate's path allowlist.
+ *
+ * INV-001: Node builtins only.
+ */
+/**
+ * One row of the manifest: a client-tree path and what the session wants there.
+ *
+ * `file` and `directory` are create-if-absent; `section` is the additive form the
+ * never-clobber rule is built around — an existing `CLAUDE.md` gains a section and
+ * keeps every byte it had.
+ */
+export type ArtefactRow = {
+    readonly path: string;
+    readonly kind: 'file';
+    readonly content: string;
+} | {
+    readonly path: string;
+    readonly kind: 'section';
+    readonly heading: string;
+    readonly body: string;
+} | {
+    readonly path: string;
+    readonly kind: 'directory';
+};
+/**
+ * What happened to one row.
+ *
+ * - `created`        — the path did not exist; it was created.
+ * - `section-added`  — an existing file gained a section and kept every byte.
+ * - `already-present`— our content/section was already there; nothing was written.
+ * - `left-alone`     — the developer already owns that path with different content;
+ *                      it was NOT overwritten, and it is reported.
+ */
+export type RowOutcome = 'created' | 'section-added' | 'already-present' | 'left-alone';
+/** One line of the printed report. `path` is repo-relative, `/`-separated. */
+export interface ManifestEntry {
+    readonly path: string;
+    readonly outcome: RowOutcome;
+    /** Why, in the developer's language — the report is load-bearing, not courteous. */
+    readonly note: string;
+}
+/** The result of applying one batch of rows (i.e. of one resolve's writes). */
+export interface WriteReport {
+    readonly entries: readonly ManifestEntry[];
+}
+/**
+ * Apply one batch of manifest rows to a project repository and report every path
+ * touched.
+ *
+ * Called once per resolve, with the rows that resolve's instruction directed — so
+ * the writes land WITH their step rather than in a terminal phase. Refuses (throws)
+ * on an undeclared path, on the reserved mirror path, and on content carrying
+ * method structure; those are gate failures, not warnings.
+ */
+export declare function applySetupWrites(targetRepo: string, rows: readonly ArtefactRow[]): WriteReport;
+/**
+ * The accumulated manifest across a run — the union of what the served steps wrote,
+ * printed once as the report the spec calls load-bearing. A setup command that works
+ * silently is indistinguishable from one that failed.
+ */
+export declare class SetupManifest {
+    private readonly rows;
+    /** Fold one resolve's report into the run's manifest. */
+    add(report: WriteReport): void;
+    /** Every row, in the order the resolves produced them. */
+    entries(): readonly ManifestEntry[];
+    /** The paths this run actually changed — created or section-added. */
+    changedPaths(): readonly string[];
+    /** True iff the run changed nothing — the honest output of a second run. */
+    nothingToDo(): boolean;
+    /**
+     * The paths this run wanted and did not get: a name the developer already uses, or
+     * a symlink it would not follow. **Not the same as "already set up"** — a run where
+     * every row is `left-alone` changed nothing *and* set nothing up, and reporting
+     * that as done is the failure the report exists to prevent.
+     */
+    leftAlonePaths(): readonly string[];
+    /**
+     * The report, in plain words. Names every path touched, including the ones left
+     * alone — a path the command decided not to write is exactly what a developer
+     * needs told.
+     *
+     * **The header describes the run's actual composition, and says nothing universal
+     * unless it holds.** Two earlier forms got this wrong in the same way, one round
+     * apart: the first printed "already set up" for a run that wrote nothing *because
+     * every path was already the developer's*, and the second printed "every path this
+     * needed is already yours" for the **mixed** state — some rows already correct
+     * from an earlier run, some blocked — which is the ordinary second-run case and is
+     * simply false. Counts are what the header is built from now, and *every* appears
+     * only when the count says every.
+     */
+    render(): string;
+}
+//# sourceMappingURL=manifest.d.ts.map

package/dist/setup/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/setup/manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AASH;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC1E;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACpG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC;AAE1D;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,eAAe,GAAG,iBAAiB,GAAG,YAAY,CAAC;AAExF,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,oFAAoF;IACpF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,+EAA+E;AAC/E,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;CAC5C;AA4aD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,WAAW,EAAE,GAAG,WAAW,CAyB9F;AAMD;;;;GAIG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAuB;IAE5C,yDAAyD;IACzD,GAAG,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAI9B,0DAA0D;IAC1D,OAAO,IAAI,SAAS,aAAa,EAAE;IAInC,sEAAsE;IACtE,YAAY,IAAI,SAAS,MAAM,EAAE;IAMjC,4EAA4E;IAC5E,WAAW,IAAI,OAAO;IAItB;;;;;OAKG;IACH,cAAc,IAAI,SAAS,MAAM,EAAE;IAInC;;;;;;;;;;;;;OAaG;IACH,MAAM,IAAI,MAAM;CAsBjB"}

package/dist/setup/rows.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The declared rows of the manifest, as row constructors (feature
+ * `halfcycle-setup`; tasks T-17 and T-18).
+ *
+ * **Why constructors rather than a table of content.** The manifest's rows are a
+ * client-tree *path* convention — `CLAUDE.md`, `AGENTS.md`, `ENGAGEMENT.md`,
+ * the tracker home and the layer-doc scaffolding under `docs/` — and those paths
+ * are what [INV-019] makes this package declare. The *content* of each row is the
+ * session's, composed from the instruction the delivery service served for that
+ * step. So each function here fixes the path and takes the content.
+ *
+ * **What is deliberately absent.** There is no function here that answers "which
+ * rows does step X write?", and no caller can ask one. The schedule — which rows
+ * land at which resolve — belongs to the served run, not to this package (see
+ * `manifest.ts`'s docblock).
+ *
+ * INV-001: no imports outside this package's own modules.
+ */
+import type { ArtefactRow } from './manifest.js';
+/** The tracker home the flat-file backend uses. `tracker-adapter-conventions` §3
+ *  pins it; this package creates the directory and nothing else — the adapter,
+ *  the vocabulary and the conformance suite are `tracker-localfile`'s. */
+export declare const FLAT_FILE_TRACKER_HOME = "docs/tasks";
+/** The project context index. Created when absent; when the developer already has
+ *  one it gains a section and keeps every byte. */
+export declare function contextIndexRow(heading: string, body: string): ArtefactRow;
+/** The pointer file that sends any other agent to the context index. Whole-file:
+ *  a developer who already has one keeps it untouched. */
+export declare function agentsPointerRow(content: string): ArtefactRow;
+/** A layer document the project does not have yet. Scaffolding only where absent
+ *  is the mechanism's job — an existing document is left alone and reported. */
+export declare function layerDocumentRow(path: string, content: string): ArtefactRow;
+/**
+ * A section added to a document the project already has, at any declared path
+ * (task T-18 — the design journey's shape, which `/halfcycle-setup` never had).
+ *
+ * **The gap this closes.** Setup writes each of its documents once, so a whole-file
+ * row was enough: `contextIndexRow` is the only additive row and it is pinned to
+ * `CLAUDE.md`. The design journey writes a document at one served step and comes
+ * back to it at a LATER one — `docs/invariants.md` is created as a template and
+ * then gains extracted invariants; a features index is created empty and then gains
+ * entries. A whole-file row at the second step would find the file present with
+ * different bytes and report `left-alone`, which is correct never-clobber behaviour
+ * and the wrong outcome for the run: the step's work would silently not land.
+ *
+ * The path is the caller's, exactly as `layerDocumentRow`'s is, and for the same
+ * reason: which document a step writes is the served instruction's to say, and this
+ * package holds no table of it. Everything that makes the row safe — the declared
+ * path allowlist, the reserved-mirror deny, the single-line heading rule and the
+ * never-clobber guarantee — is `manifest.ts`'s and is not restated here.
+ */
+export declare function documentSectionRow(path: string, heading: string, body: string): ArtefactRow;
+/** The record of the engagement's decisions. */
+export declare function engagementRecordRow(content: string): ArtefactRow;
+/** The chosen tracker's home, when it is the flat-file backend. */
+export declare function trackerHomeRow(home?: string): ArtefactRow;
+//# sourceMappingURL=rows.d.ts.map

package/dist/setup/rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rows.d.ts","sourceRoot":"","sources":["../../src/setup/rows.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;0EAE0E;AAC1E,eAAO,MAAM,sBAAsB,eAAe,CAAC;AAEnD;mDACmD;AACnD,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAE1E;AAED;0DAC0D;AAC1D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAE7D;AAED;gFACgF;AAChF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,CAE3E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAE3F;AAED,gDAAgD;AAChD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAEhE;AAED,mEAAmE;AACnE,wBAAgB,cAAc,CAAC,IAAI,GAAE,MAA+B,GAAG,WAAW,CAEjF"}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "halfcycle",
+  "version": "0.3.7",
+  "description": "Your coding agents are the engineers. Halfcycle is the rest of the team: product owner, architect, planner and independent reviewer for Claude Code.",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai-agents",
+    "agentic-coding",
+    "spec-driven-development",
+    "code-review",
+    "mcp",
+    "prd",
+    "software-architecture",
+    "ai-code-quality",
+    "engineering-process",
+    "technical-specification"
+  ],
+  "homepage": "https://halfcycle.ai",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "commands",
+    "scaffolding",
+    "bin",
+    ".claude-plugin"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "halfcycle": "./dist/bin.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/bundle-entries.mjs && node scripts/vendor-runner-bin.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json",
+    "test": "tsc -p tsconfig.test.json && node --test \"dist-test/test/\"*.test.js"
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@halfcycle/core": "workspace:*",
+    "@halfcycle/events": "workspace:*",
+    "@types/node": "^20.0.0",
+    "esbuild": "^0.28.1",
+    "typescript": "^5.0.0"
+  }
+}

package/scaffolding/test/fixtures/captured/manifest.json

@@ -0,0 +1,4 @@
+{
+  "_readme": "Halfcycle's captured-fixture store. Empty until something is captured. Halfcycle writes recorded third-party API responses under test/fixtures/captured/<provider>/<slug>.json and indexes them here, so your tests can replay a real response instead of calling the live service. It is separate from your own test directory on purpose and is not a second home for your tests — put those wherever your project already puts them. Safe to leave alone; deleting it means the next capture recreates it. This note disappears once the first fixture is captured.",
+  "entries": []
+}