@osfactory/har 1.1.0 → 1.3.0

package/dist/templates/agent-skills/factory-line.md

@@ -0,0 +1,108 @@
+# Run a factory line
+
+Execute **one station** of a declared multi-station program:
+
+sync → wave plan → parallel HAR slots → cumulative gate → human handoff.
+
+The program lives in an **installed line bundle**, not in this workflow. Find
+it with `har line status` — installed lines live at `.har/lines/<id>/line.json`
+and are recorded in `.har/lines.json`. This workflow is the orchestrator;
+station-specific how-to lives in other skills the program lists.
+
+HAR already has the primitives — work units, isolated slots, stages, plugins,
+validation records. A line is composition plus a manifest. Do not invent a
+second runner, a stack-specific MCP tool, or GitHub-shaped stations.
+
+This workflow is the same on Claude Code (`/factory-line`), Cursor
+(`.cursor/commands/factory-line`), and Codex (`har-factory-line`).
+
+## Inputs
+
+Resolve these before doing anything (ask only if not inferable):
+
+1. **Line** — run `har line status` (or MCP `har_line_status`). One installed
+   line: use it. Several: ask which. **None installed**: stop and offer
+   `har line create <id>` or `har line add <spec>` — do not invent GitHub
+   issue numbers, a fixture repo, or a program of your own.
+2. **Station id** — default: the first station whose bound work is not all
+   done / whose gate has not passed.
+3. **Slot budget** — `har env status` first. One slot per concurrent agent.
+   Occupied slots always block.
+
+## Contract (minimum)
+
+A line program is JSON with `contractVersion: 1`. Required:
+
+- `id`, `stations[]` (ordered; each has `id` + `title`)
+- `gate.cumulative` must be `true`
+- `handoff.autonomousShip` must be `false`
+
+Optional: `skills[]` and `mcp[]` (declarations + install hints — HAR does not
+vendor third-party skill packs or add core MCP tools), `plugins[]`,
+`gate.stages[]` with `fromStation` (that stage stays required from this
+station **on**), `extraStages[]`, `traveler`, `stations[].work` / `waves`.
+
+`work.source` is `github`, `linear`, `none`, or a free string — the tracker
+is data on the station, not the type of the station. If `waves` is omitted,
+the station is one sequential cell.
+
+A QA station is never removed. Adding a station must not drop earlier
+`gate.stages`. When a review finds a new class of defect, add a stage or
+doctor question and tag `fromStation` — that is how the ratchet grows.
+
+## What this workflow must not bake in
+
+Stacked PRs, a long-lived integration branch, a named fixture repo, `M0..M5`,
+and "one issue = one PR = one slot" are **instance tactics**. If the template
+does not declare them, do not do them.
+
+## 0. Load and preflight
+
+1. `har line status [id]` — read the program it names. Confirm
+   `gate.cumulative` and `handoff.autonomousShip`. `har line status` already
+   reports which stations are green and which is next.
+2. Skills and MCP: confirm required ones are present. Missing optional:
+   skip those steps and say so. Do not install third-party packs yourself.
+3. Print: line id, station id, waves, slot plan, and every gate stage whose
+   `fromStation` is this station or an earlier one.
+
+## 1. Wave plan
+
+Print `stations[].waves` (or a single cell). One HAR slot per group in a
+wave. Never share a slot between two concurrent groups.
+
+## 2. Execute waves
+
+For each wave, one subagent per group, in parallel. Each:
+
+1. Checks the slot is free. Occupied → complete/teardown that slot, or pick
+   a free slot in budget.
+2. `har env launch <slot>` with `--work-id` / `--work-source` / `--work-url`
+   / `--work-title` when work is bound. Skip tracker flags when source is
+   `none`.
+3. Edits **only** in the returned work dir.
+4. Full verify in-slot until green. If this station made a new gate question
+   askable, add it — never remove an earlier station's stages.
+5. Reports back. Subagents never push, PR, complete, or teardown on their own.
+
+## 3. Gate
+
+```bash
+har line gate <station> --line <id> --agent <slot>
+```
+
+That runs every gate stage whose `fromStation` ≤ this station — the cumulative
+set, from data. Add `--force` when the program sets `gate.optInEnv` and you
+want the opt-in jig to run anyway.
+
+Line gate stages are **not** part of `har env verify --full`, by design. Run
+both: full verify for the harness contract, `har line gate` for the station.
+
+Red gate → fix, re-run. Never hand off a red gate. Never bypass
+(`HAR_SKIP_GATE`, `--no-verify`).
+
+## 4. Handoff
+
+Update the `traveler` the template names. Then **stop and wait**. Do not
+merge, push to the default branch, complete a slot, or release. Present a
+session handoff (summary, session branch, preview URLs, gate evidence).

package/dist/templates/agent-skills/skills.manifest.json

@@ -13,8 +13,12 @@
           "allowed-tools": "Bash(har *) Bash(npm *) Bash(git *) Bash(docker *) Read Grep Glob Edit Write"
         }
       },
-      "cursor": { "command": true },
-      "codex": { "promptName": "har-setup" }
+      "cursor": {
+        "command": true
+      },
+      "codex": {
+        "promptName": "har-setup"
+      }
     },
     {
       "id": "har-wt",
@@ -26,8 +30,12 @@
           "description": "Use BEFORE making any code change in this repository. Launches a har harness slot, which creates an isolated git session worktree — all edits must happen there, never in the main checkout — and verifies the work through the harness when done."
         }
       },
-      "cursor": { "command": true },
-      "codex": { "promptName": "har-wt" }
+      "cursor": {
+        "command": true
+      },
+      "codex": {
+        "promptName": "har-wt"
+      }
     },
     {
       "id": "har-maintain",
@@ -41,8 +49,29 @@
           "allowed-tools": "Bash(har *) Bash(git *) Read Grep Glob Edit Write"
         }
       },
-      "cursor": { "command": true },
-      "codex": { "promptName": "har-maintain" }
+      "cursor": {
+        "command": true
+      },
+      "codex": {
+        "promptName": "har-maintain"
+      }
+    },
+    {
+      "id": "factory-line",
+      "body": "factory-line.md",
+      "title": "Run one station of a factory line",
+      "claude": {
+        "frontmatter": {
+          "name": "factory-line",
+          "description": "Execute one station of an installed factory line (har line status / .har/lines/<id>/line.json): parallel HAR slots, cumulative gate via har line gate, human handoff. Use when asked to run a factory line, the next station, or a milestone program."
+        }
+      },
+      "cursor": {
+        "command": true
+      },
+      "codex": {
+        "promptName": "har-factory-line"
+      }
     }
   ]
 }

package/dist/templates/lines/example-line/.github/workflows/check-manifest.yml

@@ -0,0 +1,24 @@
+name: Check line bundle
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  check-manifest:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - name: Validate line manifest and program
+        run: node scripts/check-manifest.mjs
+      - name: Stage scripts are executable
+        run: |
+          set -euo pipefail
+          for script in stages/*.sh; do
+            [ -x "$script" ] || { echo "not executable: $script" >&2; exit 1; }
+            bash -n "$script"
+          done

package/dist/templates/lines/example-line/AGENTS.md

@@ -0,0 +1,48 @@
+# Authoring guide for coding agents
+
+This repository is a **HAR factory line bundle**. Read this before changing it.
+
+## Is this a line or a verification plugin?
+
+Ask one question: **should this run on every `har env verify --full`?**
+
+| Answer | Bundle kind | Template | Install |
+|---|---|---|---|
+| Yes — it must gate every change | Verification plugin | [har-plugin](https://github.com/os-factory/har-plugin) | `har env add-plugin <spec>` |
+| No — it gates a *station* of a program | Factory line | this repo | `har line add <spec>` |
+
+Typical lines: a migration executed in waves, an onboarding program, a
+heavy proof jig (Docker lab, fixture end-to-end, device farm) that must exist
+and be runnable but must not be on the hot path of every verify.
+
+If you find yourself wanting to add a line stage to `verificationStages`, stop:
+you wanted a plugin.
+
+## Hard rules
+
+- `line.manifest.json` declares `"kind": "line"` and **must not** declare
+  `verificationStages`. The schema rejects it.
+- `gate.cumulative` is `true`. A stage tagged `fromStation: X` is required at X
+  **and every later station**. Adding a station may never drop an earlier
+  station's stages.
+- `handoff.autonomousShip` is `false`. Agents hand off; humans merge and
+  release.
+- `skills[]` and `mcp[]` are **declarations with install hints**. HAR does not
+  vendor skill packs or MCP servers, and a line never introduces a core tool
+  named after a tracker or a framework.
+- Station names, tracker ids, branch strategy, and fixture repos are *instance
+  data*. They belong in `line.json`, never in the tooling.
+
+## Validate
+
+```bash
+node scripts/check-manifest.mjs
+```
+
+Then prove the invariant on a scratch harness:
+
+```bash
+har line add ./           # from a repo with a .har/ harness
+har line status <id>
+git diff -- .har/stages.json   # verificationStages must be untouched
+```

package/dist/templates/lines/example-line/README.md

@@ -0,0 +1,72 @@
+# har-line
+
+A GitHub template for authoring **HAR factory lines**.
+
+A *factory line* is a program: an ordered set of **stations** plus a
+**cumulative gate**. It composes what HAR 1.0 already has — work units, slots,
+stages, plugins, skills, MCP. It is not a fourth marketplace and not a second
+stage runner.
+
+> **A line is not a verification plugin.** Installing a line registers its
+> stages but **never** adds them to `verificationStages`. Default
+> `har env verify --full` takes exactly as long as it did before. That is the
+> entire reason the two bundle kinds are separate.
+>
+> If your check should gate *every* verify, use
+> [os-factory/har-plugin](https://github.com/os-factory/har-plugin) instead.
+
+## Quick start
+
+1. **Use this template** → name your repo (e.g. `onboarding-line`).
+2. Rename the example: `line.manifest.json` `id`, `line.json` `id`/`title`, and
+   the stage script under `stages/`.
+3. Describe your stations in `line.json`.
+4. Install it into a product repo:
+
+```bash
+har line add github:your-org/onboarding-line
+har line status onboarding-line
+har line gate S2 --line onboarding-line
+```
+
+## Package layout
+
+```text
+har-line/
+├── line.manifest.json     # kind: line — what `har line add` applies
+├── line.json              # the program: stations, gate, handoff
+├── stages/
+│   └── example-gate.sh    # extra stage — registered, NOT on verify
+├── docs/AUTHORING.md      # how to write a line
+├── scripts/check-manifest.mjs
+└── AGENTS.md              # line vs verification plugin, for coding agents
+```
+
+## Install channels
+
+| Spec | Example |
+|---|---|
+| Local path | `har line add ./har-line` |
+| Git | `har line add github:acme/onboarding-line` |
+| npm | `har line add @acme/onboarding-line` |
+
+Add a `package.json` (name, version, `files`) only if you want the npm channel —
+git and path installs need nothing else.
+
+Resolution order is path → git → bundled id → npm, the same resolver plugins
+use. The package root must contain `line.manifest.json`.
+
+`har env add-plugin` **refuses** a line bundle and points at `har line add`.
+
+## The invariant
+
+After `har line add`, `.har/stages.json` `verificationStages` is unchanged —
+no new ids, same default verify duration. `scripts/check-manifest.mjs` asserts
+the manifest side of that; the CLI asserts the applied side and refuses to
+write if the verify plan moved.
+
+## Related
+
+- [os-factory/har](https://github.com/os-factory/har) — the CLI and MCP control plane
+- [os-factory/har-plugin](https://github.com/os-factory/har-plugin) — template for **verification plugins** (these *do* join verify)
+- [Factory lines guide](https://har.osfactory.dev/docs/guides/factory-lines/)

package/dist/templates/lines/example-line/docs/AUTHORING.md

@@ -0,0 +1,79 @@
+# Authoring a factory line
+
+## 1. The program (`line.json`)
+
+`contractVersion: 1`. Additive fields are fine; renaming a field is a new
+version.
+
+| Field | Required | Meaning |
+|---|---|---|
+| `id` | yes | Stable kebab id. Must match `line.manifest.json`. |
+| `title` | yes | Human title. |
+| `stations[]` | yes | Ordered. Array order *is* station order. |
+| `stations[].id` | yes | Stable, shell-friendly. |
+| `stations[].work` | no | Tracker binding: `source` (`github`, `linear`, `none`, …), `ids[]` passed to `har env launch --work-id`. |
+| `stations[].waves` | no | Each inner array is one wave; cells in a wave run in parallel slots. |
+| `skills[]` | no | Skills the line expects. `role` is `orchestrator` or `station`; `install` is a hint (`repo:…`, `upstream:url`, `agent-managed`). |
+| `mcp[]` | no | MCP **servers** the line expects. `required: false` means skip those steps when absent. |
+| `plugins[]` | no | Verification plugin ids the gate assumes (`har env add-plugin`). |
+| `gate.cumulative` | yes | Must be `true`. |
+| `gate.optInEnv` | no | When set (e.g. `HAR_FIXTURE_E2E`), the gate is skipped unless that env is `1`. |
+| `gate.stages[].fromStation` | yes | The ratchet tag: required from this station onward. |
+| `extraStages[]` | no | Stages this line adds beyond the profile defaults. |
+| `handoff.autonomousShip` | yes | Must be `false`. |
+| `traveler` | no | Where durable notes live given the repo's merge policy. |
+| `prototypeNotes[]` | no | Instance tactics that must not leak into the primitive. |
+
+## 2. The manifest (`line.manifest.json`)
+
+```json
+{
+  "kind": "line",
+  "id": "your-line",
+  "program": "line.json",
+  "files": [
+    { "src": "stages/your-gate.sh", "dest": ".har/stages/your-gate.sh", "executable": true }
+  ],
+  "stages": [{ "id": "your-gate", "kind": "test", "script": "stages/your-gate.sh", "tier": "full" }]
+}
+```
+
+- `files[]` are copied into the target repo verbatim.
+- `stages[]` are **registered** in `.har/stages.json` — and nothing else. They
+  are not appended to `verificationStages`, and the CLI refuses to write if
+  applying the bundle would have moved that list.
+- Declaring `verificationStages` here is a schema error, not a warning.
+
+## 3. The gate stage
+
+A line stage is an ordinary HAR stage script: stdout is one JSON result object,
+stderr is progress, `$1` is the agent slot id, artifacts go under
+`.har/artifacts/<stage-id>/`. See `.har/STAGES.md` in any harness for the full
+contract.
+
+Run it through the line, not through verify:
+
+```bash
+har line gate S2 --line your-line
+```
+
+## 4. Growing the ratchet
+
+To ask a question the previous gate forgot:
+
+1. Add a stage (or a `doctor` check) that asks it.
+2. Tag it `fromStation` of the station that made the question askable.
+3. Leave every earlier tag in place.
+
+That is how a review comment becomes a permanent question instead of a habit.
+
+## 5. Publish
+
+```bash
+git init && git commit -am "feat: my line"
+gh repo create your-org/your-line --public --source . --push
+```
+
+Consumers install with `har line add github:your-org/your-line`. For npm, keep
+`package.json` and `npm publish` — `har line add @your-org/your-line` packs it
+with `npm pack` and reads `line.manifest.json` from the package root.

package/dist/templates/lines/example-line/line.json

@@ -0,0 +1,72 @@
+{
+  "contractVersion": 1,
+  "id": "example-line",
+  "title": "Example factory line",
+  "description": "A three-station program showing the shape a factory line takes: stations that produce something, a cumulative gate that grows as the line grows, and a handoff that a human owns. Rename it and make the stations describe your own work.",
+  "skills": [
+    {
+      "id": "factory-line",
+      "role": "orchestrator",
+      "install": "repo:.claude/skills/factory-line"
+    }
+  ],
+  "mcp": [
+    {
+      "name": "github",
+      "why": "issue tracker and pull requests",
+      "required": false
+    }
+  ],
+  "plugins": [],
+  "stations": [
+    {
+      "id": "S1",
+      "title": "Draft",
+      "description": "Agree the contract before anyone writes code: schema, interfaces, the invariant that must hold.",
+      "work": { "source": "none", "ids": [], "optional": true }
+    },
+    {
+      "id": "S2",
+      "title": "Build",
+      "description": "Implement the contract in isolated slots, one work unit per slot.",
+      "work": { "source": "none", "ids": [], "optional": true }
+    },
+    {
+      "id": "S3",
+      "title": "Prove",
+      "description": "Demonstrate the invariant on a real repository, then hand off for human review.",
+      "work": { "source": "none", "ids": [], "optional": true }
+    }
+  ],
+  "gate": {
+    "cumulative": true,
+    "optInEnv": null,
+    "stages": [
+      {
+        "id": "example-gate",
+        "fromStation": "S2",
+        "tier": "full"
+      }
+    ]
+  },
+  "extraStages": [
+    {
+      "id": "example-gate",
+      "kind": "test",
+      "tier": "full",
+      "description": "Line-owned gate — registered in .har/stages.json, absent from verificationStages"
+    }
+  ],
+  "handoff": {
+    "autonomousShip": false,
+    "waitFor": "human review before merge or release"
+  },
+  "traveler": {
+    "kind": "github-issue-comment",
+    "note": "Durable notes live on the tracker issue — a squash merge drops commit-body footers."
+  },
+  "prototypeNotes": [
+    "Station names (Draft/Build/Prove) are instance data — rename them for your program.",
+    "This example binds no tracker work; set stations[].work.source and .ids to bind GitHub or Linear."
+  ]
+}

package/dist/templates/lines/example-line/line.manifest.json

@@ -0,0 +1,37 @@
+{
+  "kind": "line",
+  "id": "example-line",
+  "title": "Example factory line",
+  "program": "line.json",
+  "files": [
+    {
+      "src": "stages/example-gate.sh",
+      "dest": ".har/stages/example-gate.sh",
+      "executable": true
+    }
+  ],
+  "stages": [
+    {
+      "id": "example-gate",
+      "kind": "test",
+      "description": "Line-owned gate for example-line — registered, never on verify",
+      "script": "stages/example-gate.sh",
+      "requiresAgentId": true,
+      "artifacts": [
+        {
+          "path": ".har/artifacts/example-gate",
+          "kind": "directory",
+          "description": "Artifacts for the example-gate stage"
+        }
+      ],
+      "tier": "full"
+    }
+  ],
+  "nextSteps": [
+    "Edit .har/lines/example-line/line.json — rename the line and describe your stations",
+    "Edit .har/stages/example-gate.sh — replace the TODO with the real gate",
+    "har line status example-line",
+    "har line gate S2 --line example-line"
+  ],
+  "docsPath": ".har/lines/example-line/README.md"
+}

package/dist/templates/lines/example-line/scripts/check-manifest.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+/**
+ * Validate this line bundle without installing it.
+ *
+ * Checks the invariants that make a line a line — most importantly that the
+ * manifest declares no `verificationStages`, so applying it can never widen
+ * `har env verify --full`.
+ *
+ * Usage: node scripts/check-manifest.mjs [bundle-dir]
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { join, resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const bundleDir = resolve(process.argv[2] ?? join(dirname(fileURLToPath(import.meta.url)), '..'));
+const errors = [];
+const warnings = [];
+
+function readJson(relPath) {
+  const abs = join(bundleDir, relPath);
+  if (!existsSync(abs)) {
+    errors.push(`missing file: ${relPath}`);
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync(abs, 'utf8'));
+  } catch (err) {
+    errors.push(`invalid JSON in ${relPath}: ${err.message}`);
+    return null;
+  }
+}
+
+const manifest = readJson('line.manifest.json');
+
+if (manifest) {
+  if (manifest.kind !== 'line') {
+    errors.push('line.manifest.json must declare "kind": "line" (a plugin manifest is not a line)');
+  }
+  if (manifest.verificationStages !== undefined) {
+    errors.push(
+      'line.manifest.json must NOT declare verificationStages — line gate stages are opt-in and run via `har line gate`',
+    );
+  }
+  if (typeof manifest.id !== 'string' || !/^[a-z0-9][a-z0-9._-]*$/.test(manifest.id)) {
+    errors.push('line.manifest.json id must be a lowercase slug');
+  }
+  for (const file of manifest.files ?? []) {
+    if (!existsSync(join(bundleDir, file.src))) {
+      errors.push(`files[].src not found: ${file.src}`);
+    }
+  }
+}
+
+const program = manifest ? readJson(manifest.program ?? 'line.json') : null;
+
+if (manifest && program) {
+  if (program.id !== manifest.id) {
+    errors.push(`program id "${program.id}" does not match manifest id "${manifest.id}"`);
+  }
+  if (program.contractVersion !== 1) {
+    errors.push('program contractVersion must be 1');
+  }
+  if (program.gate?.cumulative !== true) {
+    errors.push('gate.cumulative must be true — a line never drops an earlier station\'s stages');
+  }
+  if (program.handoff?.autonomousShip !== false) {
+    errors.push('handoff.autonomousShip must be false — agents hand off, they do not ship');
+  }
+
+  const stationIds = (program.stations ?? []).map((s) => s.id);
+  if (stationIds.length === 0) {
+    errors.push('program needs at least one station');
+  }
+  if (new Set(stationIds).size !== stationIds.length) {
+    errors.push('station ids must be unique');
+  }
+
+  const registeredIds = new Set((manifest.stages ?? []).map((s) => s.id));
+  for (const stage of program.gate?.stages ?? []) {
+    if (!stationIds.includes(stage.fromStation)) {
+      errors.push(`gate stage "${stage.id}" tags unknown station "${stage.fromStation}"`);
+    }
+    if (!registeredIds.has(stage.id)) {
+      warnings.push(
+        `gate stage "${stage.id}" is not registered by this bundle — the target repo must already provide it (e.g. via a verification plugin)`,
+      );
+    }
+  }
+}
+
+for (const warning of warnings) {
+  console.warn(`warn: ${warning}`);
+}
+
+if (errors.length > 0) {
+  for (const err of errors) {
+    console.error(`error: ${err}`);
+  }
+  console.error(`\n${errors.length} error(s) in ${bundleDir}`);
+  process.exit(1);
+}
+
+console.log(`ok: ${bundleDir} is a valid HAR line bundle`);

package/dist/templates/lines/example-line/stages/example-gate.sh

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+# Line-owned gate for example-line (never on verify)
+# Custom HAR stage: example-gate (kind: test)
+#
+# Stage script contract (full reference: .har/STAGES.md):
+#   - stdout: a single JSON result object (status, stageId, agent_id, ...)
+#   - stderr: human-readable progress
+#   - $1: agent slot id; extra args may follow
+#   - artifacts: write reports/screenshots/logs under .har/artifacts/example-gate/
+#   - exit code: the real status (0 = pass)
+#
+# Usage: ./.har/stages/example-gate.sh <agent-id> [extra args...]
+set -euo pipefail
+
+# 1.0 stage surface: the runner exports WORK_DIR, ENV_FILE, AGENT_ID and
+# HAR_HARNESS_DIR, with harness.env and the slot env file already sourced —
+# agent-slot.sh is retired (1.0 migration).
+HARNESS_DIR="${HAR_HARNESS_DIR:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}"
+REPO_ROOT="$(cd "$HARNESS_DIR/.." && pwd)"
+
+AGENT_ID="${1:-${AGENT_ID:?Usage: example-gate.sh <agent-id> [extra args...]}}"
+now_ms() { node -e 'process.stdout.write(String(Date.now()))' 2>/dev/null || echo 0; }
+
+# JSON-escape step output; truncate to 50 lines in node (avoids SIGPIPE under pipefail).
+escape_step_output() {
+  printf '%s' "$1" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const s=d.trim().split('\n').slice(0,50).join('\n');process.stdout.write(JSON.stringify(s))})" 2>/dev/null || echo '""'
+}
+
+ENV_FILE="${ENV_FILE:?No slot env for agent ${AGENT_ID} — run har env launch ${AGENT_ID} first}"
+WORK_DIR="${WORK_DIR:?No slot work dir for agent ${AGENT_ID} — run har env launch ${AGENT_ID} first}"
+ARTIFACTS_DIR="$HARNESS_DIR/artifacts/example-gate"
+mkdir -p "$ARTIFACTS_DIR"
+
+echo "==> [example-gate agent-${AGENT_ID}] running in ${WORK_DIR}" >&2
+START=$(now_ms)
+
+# ── TODO: implement the stage ────────────────────────────────────────────────
+# Run your checks from $WORK_DIR (the agent's isolated checkout); the slot's
+# ports and env are loaded from $ENV_FILE. Save artifacts to $ARTIFACTS_DIR.
+set +e
+OUTPUT=$(cd "$WORK_DIR" && echo "TODO: implement .har/stages/example-gate.sh" && false)
+EXIT_CODE=$?
+set -e
+
+END=$(now_ms)
+STATUS="fail"
+[ "$EXIT_CODE" = "0" ] && STATUS="pass"
+OUTPUT_JSON=$(escape_step_output "$OUTPUT")
+
+node -e "process.stdout.write(JSON.stringify({
+  status: '$STATUS',
+  stageId: 'example-gate',
+  kind: 'test',
+  agent_id: $AGENT_ID,
+  total_ms: $(( END - START )),
+  output: $OUTPUT_JSON
+}, null, 2) + '\n');"
+
+exit "$EXIT_CODE"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@osfactory/har",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "HAR: open agent harness CLI and MCP server for coding agents, isolated worktrees, and software-factory workflows",
   "keywords": [
     "har",