halfcycle 0.3.7

package/commands/agent-teams-orchestration.md

@@ -0,0 +1,11 @@
+---
+description: Take a plan that already exists and drive ALL of it through to done across several workers at once, rather than handing out the pieces one at a time
+---
+
+Resolve `/agent-teams-orchestration` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. Some steps of the method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+
+If resolution fails, report exactly this and stop:
+
+> Couldn't reach Halfcycle to resolve `/agent-teams-orchestration`. **Nothing has run.**
+> Retry when you're back online — or coordinate the workers manually from
+> the phase's approved task graph.

package/commands/consistency-check.md

@@ -0,0 +1,11 @@
+---
+description: Check a drafted feature spec against the invariants and its adjacent specs, from a session that did not write it
+---
+
+Resolve `/consistency-check` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. Some steps of the method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+
+If resolution fails, report exactly this and stop:
+
+> Couldn't reach Halfcycle to resolve `/consistency-check`. **Nothing has run.**
+> Retry when you're back online — or review the spec manually against
+> `docs/invariants.md` and its adjacent specs.

package/commands/context-update.md

@@ -0,0 +1,11 @@
+---
+description: Route recent changes into the repo's context surfaces
+---
+
+Resolve `/context-update` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. Some steps of the method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+
+If resolution fails, report exactly this and stop:
+
+> Couldn't reach Halfcycle to resolve `/context-update`. **Nothing has run.**
+> Retry when you're back online — or update the context surfaces manually
+> from this session's changes.

package/commands/halfcycle-design.md

@@ -0,0 +1,11 @@
+---
+description: Work out what the product is — the design journey to a PRD and phases
+---
+
+Resolve `/halfcycle-design` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. Some steps of the method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+
+If resolution fails, report exactly this and stop:
+
+> Couldn't reach Halfcycle to resolve `/halfcycle-design`. **Nothing has run.**
+> Retry when you're back online — or work the product definition out
+> manually, starting from the problem and who has it.

package/commands/halfcycle-setup.md

@@ -0,0 +1,11 @@
+---
+description: Set up a repository for a Halfcycle engagement
+---
+
+Resolve `/halfcycle-setup` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. Some steps of the method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+
+If resolution fails, report exactly this and stop:
+
+> Couldn't reach Halfcycle to resolve `/halfcycle-setup`. **Nothing has run.**
+> Retry when you're back online — or set the repository up manually from
+> the engagement's onboarding notes.

package/commands/stack-assembly-worker.md

@@ -0,0 +1,11 @@
+---
+description: Verify a phase's assembled stack comes up end to end
+---
+
+Resolve `/stack-assembly-worker` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. Some steps of the method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+
+If resolution fails, report exactly this and stop:
+
+> Couldn't reach Halfcycle to resolve `/stack-assembly-worker`. **Nothing has run.**
+> Retry when you're back online — or verify the assembled stack manually
+> against the phase's done-when criteria.

package/commands/task-execution.md

@@ -0,0 +1,11 @@
+---
+description: Do ONE piece of the planned work, on its own — not the whole plan
+---
+
+Resolve `/task-execution` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. Some steps of the method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+
+If resolution fails, report exactly this and stop:
+
+> Couldn't reach Halfcycle to resolve `/task-execution`. **Nothing has run.**
+> Retry when you're back online — or execute the task manually from its
+> row in the approved task graph.

package/commands/task-graph.md

@@ -0,0 +1,11 @@
+---
+description: Break the next chunk of work into ordered pieces that can be handed out — what has to happen before what, and who could take each
+---
+
+Resolve `/task-graph` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. Some steps of the method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+
+If resolution fails, report exactly this and stop:
+
+> Couldn't reach Halfcycle to resolve `/task-graph`. **Nothing has run.**
+> Retry when you're back online — or plan the phase manually from the
+> phase document's ready specs.

package/commands/write-spec.md

@@ -0,0 +1,11 @@
+---
+description: Draft a Layer 4 feature spec
+---
+
+Resolve `/write-spec` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. Some steps of the method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+
+If resolution fails, report exactly this and stop:
+
+> Couldn't reach Halfcycle to resolve `/write-spec`. **Nothing has run.**
+> Retry when you're back online — or draft the spec manually from the
+> template's required sections.

package/dist/account-credential.d.ts

@@ -0,0 +1,94 @@
+/**
+ * The PER-USER account credential store — `~/.halfcycle/account.json` (T-08,
+ * feature `connect-signup-and-credential`).
+ *
+ * This is where the credential the browser handoff mints is kept between runs, so
+ * that *"an already-signed-in machine skips all of it"* is true. It is a store of
+ * ONE secret per control origin, and it lives OUTSIDE every repository.
+ *
+ * ---------------------------------------------------------------------------
+ * WHAT THIS IS NOT, because two credentials with adjacent homes is exactly how a
+ * later edit puts the wrong one in the wrong file.
+ *
+ *   - It is NOT the engagement token. That credential authenticates a REPOSITORY,
+ *     is minted once on create, and today lives in the target repo's `.env.local`
+ *     (`install.ts`'s `writeDeviceCredential`). T-09 moves it to a machine-level
+ *     per-engagement env file at `~/.halfcycle/engagements/<id>/env`, because two
+ *     POSIX shell consumers must SOURCE it. This file is deliberately elsewhere in
+ *     that layout and deliberately JSON: nothing sources it, only this CLI reads it.
+ *   - It is NOT keyed on an engagement. An account credential is minted BEFORE any
+ *     engagement exists — that is the whole reason the create route can require one.
+ *     It is keyed on the CONTROL ORIGIN that minted it, because a developer pointed
+ *     at a dev plane and a prod plane holds two different accounts, and a single
+ *     unkeyed slot would silently hand one plane's secret to the other. That is not
+ *     a leak (the wrong plane refuses it) but it is an un-debuggable 401.
+ *
+ * ---------------------------------------------------------------------------
+ * OWNER-ONLY, AND WHAT THAT MEANS WHERE IT MEANS NOTHING. The directory is created
+ * `0700` and the file written `0600`, matching the Studio layout
+ * (`docs/features/mac-workspace-provider.md:27`) this feature adopts. The mode is
+ * applied with an explicit `chmodSync` AFTER the write and not left to the `mode`
+ * option alone, because `writeFileSync`'s `mode` is honoured only when the file is
+ * CREATED — a store that already existed at `0644` would keep those bits forever,
+ * which is a permission bug with no symptom.
+ *
+ * On Windows the POSIX mode bits are meaningless and `chmod` is a near no-op. That
+ * is a KNOWN OPEN DECISION (phase decision 6, still open, and T-09's to close for
+ * the engagement credential), not something this file pretends to have solved: the
+ * call is skipped rather than issued-and-ignored, so nothing here reads as a
+ * protection that is not there.
+ *
+ * ---------------------------------------------------------------------------
+ * `expiresAt` IS INFORMATION, NEVER A GATE. Control extends the credential's
+ * lifetime silently on every use (`resolveAccountCredential`, the one home of the
+ * 30-day window) and no response tells this client the extended value — so the
+ * instant stored here is the ISSUE-time expiry and is already stale the first time
+ * the credential is used. This module therefore never refuses a credential for
+ * being past it, and no caller may: whether a credential is live is CONTROL's
+ * question, answered with a 401. A client that decided locally would log a
+ * developer out of a credential the server was perfectly happy with, and would be a
+ * second home for a lifetime nobody could then change in one place.
+ *
+ * INV-001: Node builtins only.
+ */
+/** The per-user Halfcycle directory. One home for the path shape. */
+export declare function halfcycleHome(home?: string): string;
+/** The account-credential store's absolute path. */
+export declare function accountStorePath(home?: string): string;
+/** One stored credential — what the poll handed back, plus when it was stored. */
+export interface StoredAccountCredential {
+    /** The account the credential speaks for, as control reported it. */
+    accountId: string;
+    /** The plaintext credential. Presented as `Authorization: Bearer`. */
+    credential: string;
+    /** Control's issue-time expiry, UTC ISO-8601. Information only — see the header. */
+    expiresAt: string;
+    /** When this machine stored it, UTC ISO-8601. For the human, not for a check. */
+    signedInAt: string;
+}
+/** The credential stored for a control origin, if this machine has signed in to it. */
+export declare function readStoredCredential(serviceUrl: string, home?: string): StoredAccountCredential | undefined;
+/**
+ * Store the credential for a control origin, replacing any previous one.
+ *
+ * REPLACES rather than accumulates, and that is not the eviction the additive-token
+ * work exists to prevent: control keeps every credential it issued (they are
+ * additive by design, `issueAccountCredential`), so a second machine signing in
+ * does not invalidate this one. What is replaced is only THIS machine's local copy
+ * for THIS origin, which is the newest one it was handed.
+ */
+export declare function writeStoredCredential(serviceUrl: string, entry: Omit<StoredAccountCredential, 'signedInAt'> & {
+    signedInAt?: string;
+}, home?: string): void;
+/**
+ * Forget the credential for one origin. Returns true iff there was one.
+ *
+ * The one caller is the refusal path: a stored credential control answers 401 to is
+ * dead beyond recovery — there is no grace window on this credential class and
+ * nothing rotates it — so keeping it would mean every later run presenting a value
+ * that can only ever fail. Forgetting it is what makes the next run's browser
+ * handoff the automatic recovery rather than something the developer has to be told
+ * to trigger by deleting a file.
+ */
+export declare function forgetStoredCredential(serviceUrl: string, home?: string): boolean;
+//# sourceMappingURL=account-credential.d.ts.map

package/dist/account-credential.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-credential.d.ts","sourceRoot":"","sources":["../src/account-credential.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAMH,qEAAqE;AACrE,wBAAgB,aAAa,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,oDAAoD;AACpD,wBAAgB,gBAAgB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,kFAAkF;AAClF,MAAM,WAAW,uBAAuB;IACtC,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB,sEAAsE;IACtE,UAAU,EAAE,MAAM,CAAC;IACnB,oFAAoF;IACpF,SAAS,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,UAAU,EAAE,MAAM,CAAC;CACpB;AAsED,uFAAuF;AACvF,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,IAAI,CAAC,EAAE,MAAM,GACZ,uBAAuB,GAAG,SAAS,CAMrC;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,IAAI,CAAC,uBAAuB,EAAE,YAAY,CAAC,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5E,IAAI,CAAC,EAAE,MAAM,GACZ,IAAI,CASN;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAOjF"}

package/dist/bin.d.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * `halfcycle` CLI entry point (published bin name; formerly `halfcycle-bundle`).
+ *
+ * The bare form installs into the CURRENT directory — `npx halfcycle` in a
+ * project folder is the primary distribution path (operator decision (an)).
+ *
+ * Subcommands:
+ *   halfcycle [install] [target-repo]        — install into target (default: cwd)
+ *   halfcycle check-drift <target>           — report bundle drift for the re-sync gate
+ *   halfcycle build-record <phase>           — assemble the phase Build Record (D1)
+ *   halfcycle open-phase <phase>             — open a phase, with its entry decision
+ *   halfcycle close-phase <phase>            — record a phase's acceptance and close it
+ *
+ * EVERY NON-INSTALL SUBCOMMAND MUST BE NAMED IN `bareTarget` BELOW. The bare form
+ * (`npx halfcycle` / `npx halfcycle ./repo`) treats the first positional as an
+ * install target, so a subcommand missing from that list is not "unknown command" —
+ * it is silently an install into a directory named after the verb.
+ *
+ * TWO GUARDS ON THAT SHAPE (W3-F-4, walk 4). The bare-form-installs behaviour is
+ * deliberate and stays — it is the primary distribution path — but walk 4 ran the
+ * bare form intending to print the verb list and installed into the Halfcycle
+ * monorepo, mutating tracked files. The person who does that is trying to DISCOVER
+ * the CLI, so:
+ *   - `--help` / `-h` / `help` prints the verbs to stdout and exits 0. Before this
+ *     there was no non-mutating way to ask: `--help` fell through to the
+ *     unknown-command path (which does print the usage and exit 1, so discovery was
+ *     possible — but it framed a reasonable question as an error), and the other
+ *     thing a person tries is the bare form, which WRITES.
+ *   - an install whose target is the Halfcycle monorepo is REFUSED before any write.
+ *     Not a general install gate — the one target that is never legitimate.
+ */
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG"}