@structor-dev/cli 0.1.0 → 0.2.0

package/contrib/self-harness/files/README.md

@@ -0,0 +1,32 @@
+# Structor Self-Harness
+
+This generated harness guides work on the Structor source repository. Structor
+is the toolkit that generates repository-local AI engineering harnesses.
+Harness engineering is the practice Structor supports.
+
+## Workspace
+
+Expected local shape:
+
+```text
+workspace/
+  structor/       # source repo contributors edit
+  structor-self/  # generated self-harness
+```
+
+## Start Here
+
+1. `./AGENTS.md`
+2. `./ai/AGENTS.md`
+3. `./ai/HUB.md`
+4. `./ai/context.md`
+5. The smallest topical doc selected by the hub
+
+## Validation
+
+- Validate this self-harness with `node scripts/validate-governance.mjs`.
+- Validate workspace routing with `node scripts/check-workspace.mjs`.
+- Validate Structor source changes from `../structor` with `npm run validate`.
+
+Keep this repository as guidance and policy. Do not add runner behavior,
+orchestration, PR automation, or external-service mutation here.

package/contrib/self-harness/files/ai/AGENTS.md

@@ -0,0 +1,35 @@
+# Structor Self-Harness Shared AI Guide
+
+This folder holds canonical guidance for contributing to Structor itself.
+
+## Scope
+
+- Structor-specific contribution boundaries and review habits.
+- Context routing for generator, template, schema, CLI, and docs changes.
+- Validation expectations for issue work in the Structor source repo.
+
+## Rules
+
+- Structor is the toolkit/product. Harness engineering is the practice.
+- Structor is a generator, not a runner, orchestrator, agent runtime, PR
+  automation system, dashboard, or external-service integration layer.
+- Keep active templates in `../structor/template/**` generic and reusable.
+- Keep shared guidance model-neutral. Keep model overlays and consumer
+  entrypoints thin. Canonical generated policy belongs in
+  `../structor/template/ai/*`.
+- Generated self-harness content belongs in this repository or
+  `../structor/contrib/self-harness/**`, not in the active generic templates.
+- Issue work should be narrow, regression-driven, and validated before review.
+- Use `npm run validate` in `../structor` as the default full local gate.
+- Use `node scripts/validate-governance.mjs` here after changing self-harness
+  guidance.
+
+## Read Order
+
+1. `./ai/context.md`
+2. `./ai/HUB.md`
+3. `./ai/PRODUCT.md`
+4. `./ai/ARCHITECTURE.md`
+5. `./ai/QUALITY.md`
+
+Load additional files only when the task clearly needs them.

package/contrib/self-harness/files/ai/ARCHITECTURE.md

@@ -0,0 +1,38 @@
+# Structor Architecture
+
+This document maps the parts of the Structor source repo agents most often need
+for narrow contribution work.
+
+## System Shape
+
+- `../structor/bin/structor.mjs`: public CLI commands and guided setup.
+- `../structor/scripts/init-harness.mjs`: deterministic harness renderer.
+- `../structor/scripts/lib.mjs`: config resolution, path boundaries, and write
+  safety helpers.
+- `../structor/scripts/generated-harness-contract.mjs`: generated artifact and
+  validator contract.
+- `../structor/scripts/rendered-config.mjs`: template value rendering.
+- `../structor/template/**`: generic generated-harness templates.
+- `../structor/schemas/**`: config and task schemas.
+- `../structor/test/**`: regression coverage for CLI, config, rendering, and
+  path safety.
+- `../structor/contrib/self-harness/**`: Structor-specific self-harness source.
+
+## Ownership Boundaries
+
+- Generic generated policy belongs in `../structor/template/ai/*`.
+- Structor-specific contributor guidance belongs in
+  `../structor/contrib/self-harness/**` and the generated `structor-self`
+  sibling.
+- CLI convenience can prepare local files, but it must not clone, push, open PRs,
+  require GitHub auth, or mutate remote services for this manual path.
+- Path and write-safety changes belong close to `scripts/lib.mjs` and must have
+  regression coverage.
+
+## Change Guidance
+
+- Keep issue work small and tied to the live issue acceptance criteria.
+- Add regression tests for behavioral changes in scripts or validators.
+- Prefer existing helpers over new abstractions.
+- Treat `template/**/*.tpl` as shipped runtime surface, not inert docs.
+- Validate generated output when changing templates or rendering behavior.

package/contrib/self-harness/files/ai/HUB.md

@@ -0,0 +1,59 @@
+# Structor Self-Harness Hub
+
+This is the routing layer for work on Structor.
+
+## Baseline
+
+Always read:
+
+- `./AGENTS.md`
+- `./ai/AGENTS.md`
+- `./ai/context.md`
+
+## Routing
+
+- Product language, naming, or contribution boundaries:
+  `./ai/PRODUCT-SUMMARY.md`, `./ai/PRODUCT.md`
+- Generator flow, template boundaries, config resolution, or write safety:
+  `./ai/ARCHITECTURE.md`, `./ai/DESIGN.md`
+- Validation, review evidence, or issue completion:
+  `./ai/QUALITY.md`, `./ai/READINESS.md`, `./ai/DECISIONS.md`
+- Harness policy, active generic templates, model overlays, or consumer
+  entrypoints:
+  `./ai/HARNESS.md`, `./ai/HARNESS-ENGINEERING.md`,
+  `./ai/workspace/REPOS.md`, `./ai/workspace/SYSTEM-MAP.md`,
+  `./ai/workspace/SESSION-BOOTSTRAP.md`, `./ai/workspace/LOCAL-STACK.md`,
+  `./ai/workspace/TEST-STRATEGY.md`
+- Runner, orchestration, automation, future contributor bootstrap, or
+  external-service boundaries:
+  `./ai/WORKFLOW.md`, `./ai/RUNNER-SAFETY.md`,
+  `./ai/RUNNER-READINESS.md`, `./ai/VERSIONING.md`
+- Codex hook surfaces, repo-local hooks, or client safety:
+  `./ai/CODEX-HOOKS.md`
+- Contracts, protected surfaces, and release or GitHub safety:
+  `./ai/contracts/README.md` and the matching contract doc
+- Task-shape or issue-template changes:
+  `./ai/templates/README.md` and the matching template
+- Generated HTML review views:
+  `./ai/views/index.html` plus canonical Markdown, JSON, and YAML sources
+- Review requests:
+  `./ai/skills/README.md` and the matching review skill
+- Repeated agent mistakes:
+  `./ai/AGENT-GARBAGE-COLLECTION.md`
+
+## Source Docs
+
+Ground Structor-specific claims in the source repo:
+
+- `../structor/README.md`
+- `../structor/CONTEXT.md`
+- `../structor/CONTRIBUTING.md`
+- `../structor/docs/adr/*`
+- `../structor/scripts/**`
+- `../structor/template/**`
+
+## Load Rules
+
+- Load the smallest doc set that can answer the task.
+- Prefer current source files over memory or generated summaries.
+- Keep generated self-harness guidance out of active generic templates.

package/contrib/self-harness/files/ai/PRODUCT.md

@@ -0,0 +1,36 @@
+# Structor Product Context
+
+Structor is early infrastructure for harness engineering. It generates
+repository-local AI engineering harnesses for consumer repositories.
+
+## Product Model
+
+- **Structor** is the toolkit and CLI.
+- **Harness engineering** is the practice of shaping durable AI guidance,
+  contracts, routing, and validation for software work.
+- **Generated harnesses** are sibling repositories that own guidance, contracts,
+  review templates, and validators for a project workspace.
+- **Consumer repositories** own implementation, runtime behavior, tests, and
+  deployment-specific details.
+- **Structor Self-Harness** is a generated harness whose consumer repository is
+  Structor itself.
+
+## User Promise
+
+Structor should help contributors and teams make agent work more reliable by
+turning guidance into versioned local files plus mechanical checks. It should
+stay local, deterministic, inspectable, and conservative.
+
+## Non-Goals
+
+- Do not turn Structor into a runner or orchestrator.
+- Do not add polling, PR automation, auto-merge, dashboards, or external writes
+  to core Structor.
+- Do not put Structor-specific product content into active generic templates.
+- Do not build the future `structor contribute structor` command until the
+  self-harness guidance is worth showing.
+
+## Source Evidence
+
+Use `../structor/README.md`, `../structor/CONTEXT.md`, and
+`../structor/CONTRIBUTING.md` as the current terminology sources.

package/contrib/self-harness/files/ai/QUALITY.md

@@ -0,0 +1,31 @@
+# Structor Contribution Quality
+
+Keep Structor changes small, evidence-backed, and easy to review.
+
+| Domain | Grade | Evidence | Enforced by | Blocking gaps |
+| --- | --- | --- | --- | --- |
+| Product boundary | A | `README.md`, `CONTEXT.md`, `CONTRIBUTING.md` | Manual review | Keep runner behavior out of Structor core |
+| Generic templates | A | `template/**`, `scripts/generated-harness-contract.mjs` | `npm run validate` | Do not add Structor-specific content to active templates |
+| Path safety | A | `scripts/lib.mjs`, `test/init-harness.test.mjs` | `npm test` | Add exploit-shaped regressions for write-path changes |
+| Contributor setup | B | `contrib/self-harness/**`, `scripts/setup-contributor.mjs` | Manual setup validation | Keep future bootstrap out of this path |
+| Issue work | A | Live issue scope and regression evidence | Review | Avoid opportunistic refactors |
+| Readiness | B | `ai/READINESS.md`, `scripts/check-readiness.mjs` | `node scripts/validate-governance.mjs` | Preserve the manual-review state for skipped source entrypoints |
+
+## Completion Checklist
+
+- The diff is scoped to the issue.
+- Generic templates remain reusable for consumer projects.
+- Source-repo pointer files are previewed and existing files are skipped unless
+  force is explicit.
+- `npm run validate` passes in `../structor`.
+- `npm run setup:contributor -- --dry-run` previews generated self-harness and
+  source pointer writes.
+- `npm run setup:contributor` generates or refreshes `../structor-self`.
+- `node scripts/validate-governance.mjs` passes in `../structor-self`.
+- `node scripts/check-workspace.mjs` passes in `../structor-self`.
+
+## Review Posture
+
+Lead with risks, regressions, and missing evidence. Summaries come after
+findings. When there are no findings, say that directly and name any remaining
+test gaps.

package/contrib/self-harness/files/ai/context.md

@@ -0,0 +1,38 @@
+# Structor Self-Harness Context
+
+## Current Focus
+
+- Make Structor contribution work easier to route, bound, and validate.
+- Preserve the distinction between Structor as a toolkit and harness engineering
+  as the practice.
+- Keep the future one-command contributor bootstrap behind the quality of this
+  self-harness guidance.
+
+## Source Repo
+
+- `../structor/package.json` owns CLI scripts and local validation commands.
+- `../structor/bin/structor.mjs` owns the public CLI surface.
+- `../structor/scripts/init-harness.mjs` renders generated harnesses from
+  configuration and templates.
+- `../structor/scripts/lib.mjs` owns config resolution and path safety.
+- `../structor/template/**` is the active generic generated-harness surface.
+- `../structor/contrib/self-harness/**` owns this self-harness preset and
+  Structor-specific generated guidance.
+
+## Boundaries
+
+- Structor scaffolds harness repositories; it does not run agents.
+- Structor must not poll sessions, automate pull requests, auto-merge, mutate
+  GitHub, or become a runner.
+- Active templates must stay generic for consumer projects.
+- Model overlays and consumer entrypoints stay thin and route to canonical
+  harness policy.
+- Source-repo pointer files should be previewed and skipped when they already
+  exist unless an explicit force path is used.
+
+## Validation Defaults
+
+- In `../structor`, run `npm run validate` for the full local gate.
+- For focused generator changes, also run the relevant `npm test` coverage.
+- In this self-harness, run `node scripts/validate-governance.mjs`.
+- After setup or pointer changes, run `node scripts/check-workspace.mjs`.

package/contrib/self-harness/files/scripts/check-workspace.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+import { access, readFile } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const workspaceRoot = path.resolve(repoRoot, "..");
+const sourceRoot = path.join(workspaceRoot, "structor");
+const workspaceAgentPath = path.join(workspaceRoot, "AGENTS.md");
+const requiredHarnessFiles = [
+  "AGENTS.md",
+  "ai/AGENTS.md",
+  "ai/HUB.md",
+  "ai/context.md",
+  "scripts/validate-governance.mjs",
+];
+
+async function exists(filePath) {
+  try {
+    await access(filePath, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readIfExists(filePath) {
+  if (!(await exists(filePath))) return null;
+  return readFile(filePath, "utf8");
+}
+
+const errors = [];
+if (path.basename(repoRoot) !== "structor-self") {
+  errors.push(`repo folder name: expected structor-self, found ${path.basename(repoRoot)}`);
+}
+
+for (const relativePath of requiredHarnessFiles) {
+  if (!(await exists(path.join(repoRoot, relativePath)))) {
+    errors.push(`missing self-harness file ${relativePath}`);
+  }
+}
+
+if (!(await exists(sourceRoot))) {
+  errors.push(`missing Structor source repo at ${sourceRoot}`);
+}
+
+const workspaceAgent = await readIfExists(workspaceAgentPath);
+if (workspaceAgent === null) {
+  errors.push(`missing workspace entrypoint ${workspaceAgentPath}`);
+} else if (!workspaceAgent.includes("structor-self")) {
+  errors.push(`workspace entrypoint ${workspaceAgentPath} must route to structor-self`);
+}
+
+const sourceAgentPath = path.join(sourceRoot, "AGENTS.md");
+const sourceAgent = await readIfExists(sourceAgentPath);
+if (sourceAgent === null) {
+  errors.push(`missing source entrypoint ${sourceAgentPath}`);
+} else if (sourceAgent.includes("structor-self")) {
+  console.log("Source AGENTS.md routes to structor-self.");
+} else {
+  console.log("Source AGENTS.md exists and was preserved; run setup with --force after review to replace it.");
+}
+
+if (errors.length > 0) {
+  console.error("Structor self-harness workspace check failed.");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log("Structor self-harness workspace check passed.");

package/contrib/self-harness/harness.config.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "../../schemas/harness-config.schema.json",
+  "project": {
+    "name": "Structor Self-Harness",
+    "slug": "structor-self",
+    "harnessRepoName": "structor-self"
+  },
+  "output": {
+    "path": "./structor-self"
+  },
+  "models": {
+    "openai": true,
+    "anthropic": false
+  },
+  "clientSupport": {
+    "codex": {
+      "hooks": true
+    },
+    "claude": {
+      "rules": false,
+      "hooks": false,
+      "skills": false
+    }
+  },
+  "consumers": [
+    {
+      "name": "structor",
+      "path": "./structor",
+      "purpose": "Structor source repository: the generator, templates, schemas, docs, tests, and CLI for repository-local AI engineering harnesses.",
+      "validation": {
+        "install": "npm install",
+        "test": "npm test",
+        "health": "npm run validate"
+      }
+    }
+  ]
+}

package/docs/CONTRIBUTOR-SETUP.md

@@ -0,0 +1,45 @@
+# Structor Contributor Setup
+
+The manual contributor setup path is for people who already cloned Structor and
+want the local self-harness without the future contributor bootstrap.
+
+```sh
+git clone https://github.com/nicolaycamacho/structor.git
+cd structor
+npm run setup:contributor -- --dry-run
+npm run setup:contributor
+```
+
+The command generates or refreshes a sibling self-harness:
+
+```text
+workspace/
+  structor/       # source repo contributors edit
+  structor-self/  # generated Structor Self-Harness
+```
+
+## Safety Model
+
+- The preset source lives in `contrib/self-harness/**`.
+- Generated Structor-specific guidance is written to the sibling
+  `structor-self` harness, not to active generic templates.
+- The source repo is treated as the self-harness consumer repo.
+- Source-repo pointer files are previewed before writes.
+- Existing source `AGENTS.md`, `CLAUDE.md`, or other contributor entrypoints are
+  skipped unless `--force` is passed.
+- The manual path does not clone repositories, require GitHub authentication,
+  push branches, open pull requests, or mutate external services.
+
+## Validation
+
+After setup:
+
+```sh
+npm run validate
+cd ../structor-self
+node scripts/validate-governance.mjs
+node scripts/check-workspace.mjs
+```
+
+Use `--force` only after reviewing the preview and deciding to replace existing
+source-repo pointer files.

package/docs/INIT.md

@@ -1,8 +1,10 @@
 # Structor Init
 
 `structor init` is the recommended first-run setup flow for a project workspace.
-It is a local-only, deterministic terminal wizard. It does not call an LLM, make
-API requests, install packages, create remotes, or modify external services.
+It is a local-only, deterministic terminal wizard for creating a
+repository-local AI engineering harness. It does not call an LLM, make API
+requests, install packages, create remotes, run agents, or modify external
+services.
 
 ## Recommended Command
 
@@ -21,6 +23,29 @@ During local development from this repo, use:
 npm run init -- --workspace ..
 ```
 
+The current CLI supports `init`, `generate`, and `doctor`. It does not include a
+runner command.
+
+## First Successful Local Path
+
+The default first-run path is:
+
+1. Run `npx @structor-dev/cli init` from the parent workspace folder.
+2. Confirm the workspace, project name, generated harness path, agent clients,
+   and consumer repos.
+3. Let Structor write `harness.config.json` only after reviewing the summary.
+4. Review the dry-run preview of generated harness and consumer pointer files.
+5. Confirm generation only if the preview is correct.
+6. Run the next validation commands printed by the CLI.
+
+During development from this repository, the equivalent local command is
+`npm run init -- --workspace ..`.
+
+This path creates a sibling generated harness repo with canonical `ai/*`
+policy, thin Codex and Claude entrypoints, contracts, task templates, review
+guidance, and local validation scripts. It does not create a runner or hosted
+service; generated files remain local until you review and commit them.
+
 ## What It Reads
 
 - The current workspace folder, or the folder passed with `--workspace`.
@@ -42,6 +67,10 @@ Only after confirmation, it can write:
 Existing generated harness files and consumer entrypoints are skipped by the
 underlying generator unless the user passes `--force`.
 
+Consumer entrypoints are thin pointer files. They route Codex and Claude Code
+back to the generated harness; they are not copies of the canonical harness
+policy.
+
 ## What It Never Does
 
 - No network calls.
@@ -52,6 +81,10 @@ underlying generator unless the user passes `--force`.
 - No runner behavior such as polling, auto-repair loops, dashboards, or
   auto-merge.
 
+If setup discovers a missing behavior or incorrect wizard behavior, track that
+as a separate CLI issue instead of changing templates or generated behavior as
+part of documentation work.
+
 ## Workspace Detection
 
 Structor works best when run from a parent workspace folder:
@@ -90,6 +123,10 @@ implementation.
 - Codex and Claude support flags
 - consumer repo paths, purposes, and validation commands
 
+Consumer repo paths are workspace-relative. The generator rejects absolute
+consumer paths, `..` traversal, symlinked consumer paths, and entrypoint writes
+to directories that do not look like repositories.
+
 `structor generate --config harness.config.json` uses this file to render the
 generated harness deterministically.
 
@@ -107,3 +144,19 @@ does not infer real project contracts, coding conventions, or architecture from
 consumer repo code.
 
 `Light scan` and `Deep scan` are reserved for future opt-in features.
+
+## Validation Split
+
+Use the Structor package scripts from `package.json`:
+
+```sh
+npm run check:ci
+npm run validate
+```
+
+`npm run check:ci` runs the fast structural checks used for local iteration and
+CI hygiene.
+
+`npm run validate` runs `check:ci`, the Node test suite, and the smoke-tested
+initialization flow that generates disposable harnesses and verifies generated
+governance and workspace routing.

package/docs/public-launch.md

@@ -0,0 +1,150 @@
+# Public Launch Positioning
+
+This is planning material for future external website and article work. It is
+not polished marketing copy, not a landing page implementation, and not a
+commitment to hosted services, analytics, forms, deployment, commercial assets
+inside the open-source core, private policy packs, private templates, or
+client-specific deliverables.
+
+Structor should be presented as a local, open-source harness-engineering
+toolkit. It generates repository-local AI engineering harnesses for consumer
+repositories so coding agents share a consistent policy layer for context
+routing, contracts, task shape, review, and validation.
+
+## Approved Positioning
+
+- Structor generates a repository-local AI engineering harness for your
+  project.
+- Structor is a generator, not a runtime.
+- Structor scaffolds the harness; it does not run agents, poll sessions,
+  automate pull requests, auto-merge changes, or touch external services.
+- The open-source generator is local-only: no telemetry, no LLM calls, and no
+  network calls during `init` or `generate`.
+- Structor is MIT-licensed so teams can generate, modify, and use harness
+  artifacts inside private or commercial repositories.
+- Reliable agentic engineering needs more than prompts. It needs context
+  architecture plus mechanical enforcement.
+
+## Audience Split
+
+### Individual Developers
+
+Individual developers should understand Structor as a way to stop rebuilding
+agent instructions from scratch in every repo. The promise is practical and
+local: generate a repo-shaped harness, keep Codex and Claude guidance
+consistent, and use validation to catch policy drift before it becomes review
+noise.
+
+The right tone is direct and tool-focused. Avoid implying that Structor replaces
+the developer's judgment, runs the agent, hosts an agent workspace, or manages
+pull requests.
+
+### Teams And Companies
+
+Teams should understand Structor as a reusable harness layer for private and
+commercial codebases. The open-source core can generate and validate local
+harness artifacts that teams own in their repositories. This is useful when
+multiple agents, models, or contributors need the same contracts, review shape,
+and safety boundaries.
+
+The right tone is operational and evidence-based. Emphasize repository-local
+policy, deterministic generation, explicit write previews, validation scripts,
+and MIT-licensed use in private repositories. Avoid implying hosted dashboards,
+telemetry, managed agent execution, deployment checks, forms, analytics, or
+private commercial assets bundled into the open-source core.
+
+### Future Commercial Support
+
+Future commercial support can be described as separate from the OSS generator.
+Possible paid offerings may include tailored rollout support, commercial policy
+packs, private templates, training, audits, or hosted services, but those should
+be framed as future or separately licensed work.
+
+The public launch should not imply that these offerings already exist, are
+included in the current package, or are required to use Structor. The OSS core
+should remain understandable and valuable on its own.
+
+## Future Landing Page Outline
+
+1. Hero
+   - Headline: Structor
+   - Supporting copy: Generate repository-local AI engineering harnesses for
+     coding agents.
+   - Boundary note: A generator, not a runner.
+2. Problem
+   - Agent workflows often rely on scattered prompts, local conventions, and
+     review memory.
+   - Without a harness, guidance drifts across repos, models, and contributors.
+3. Product
+   - Structor creates a generated harness repo beside the consumer repositories.
+   - The harness owns agent guidance, contracts, review templates, validation,
+     and model-specific entrypoints.
+4. Local Safety Model
+   - `init` and `generate` are deterministic and local-only.
+   - No telemetry, no LLM calls, no network calls, and no external service
+     mutation during generation.
+5. Harness, Not Runner
+   - Structor does not execute agents, monitor sessions, open pull requests,
+     auto-merge, deploy, or manage production systems.
+   - Runner or orchestration behavior belongs in a separate layer.
+6. For Individuals
+   - Make one repo's agent guidance easier to start, inspect, and validate.
+7. For Teams
+   - Share a consistent local policy layer across models, contributors, and
+     private repositories.
+8. Open Source Core
+   - MIT-licensed generator.
+   - Local artifacts that users can inspect, commit, modify, or remove.
+9. Future Support
+   - Separately licensed support, policy packs, private templates, audits, or
+     hosted services may be explored later.
+   - Keep this section clearly separate from current OSS behavior.
+10. Next Step
+    - Point readers to the README and `docs/INIT.md` for the current local setup
+      flow.
+
+## Article Outline
+
+Working title: "Your AI coding agents need a harness, not just prompts."
+
+1. The prompt pile problem
+   - Most teams start with instructions scattered across READMEs, local notes,
+     model-specific files, and review comments.
+   - The result is inconsistent context, unclear task shape, and repeated review
+     corrections.
+2. What a harness adds
+   - A harness gives agents a repository-local policy layer.
+   - It records contracts, routing, validation, task shape, and review
+     expectations as files that can be inspected and versioned.
+3. Why local matters
+   - Teams need to understand what the tool reads and writes.
+   - Local deterministic generation is easier to review than remote automation
+     or hidden runtime behavior.
+4. Why validation matters
+   - Policy files drift.
+   - Mechanical checks make the harness more than a folder of advice.
+5. Harness is not runner
+   - A harness shapes work; it does not execute the work.
+   - Running agents, polling sessions, PR automation, deployment, and hosted
+     workflows belong in separate systems.
+6. Where Structor fits
+   - Structor generates the local harness structure and starter policy for a
+     consumer workspace.
+   - The generated harness can support Codex, Claude Code, contracts, review
+     templates, and validation without taking over the user's repository.
+7. What comes later
+   - Future website material can discuss support, commercial policy packs,
+     private templates, training, audits, or hosted services only as separate
+     work.
+   - Keep the open-source generator's current behavior precise.
+
+## Language To Avoid
+
+- Do not say Structor runs agents, supervises agents, manages sessions, opens
+  pull requests, auto-merges, deploys, or repairs repositories.
+- Do not imply current hosted services, telemetry, analytics, forms, dashboards,
+  private policy packs, private templates, or client-specific assets.
+- Do not frame commercial support as part of the open-source package.
+- Do not describe the generated harness as a production runtime or CI system.
+- Do not replace the harness-engineering story with generic AI productivity
+  claims.