harness-language

Files (1)

• SKILL.md

SKILL.md (first lines)

# /harness-language

Set / switch / refresh a harness project's **output-language policy** — the project-wide
rule that decides which language the project's AI produces. Two target states are
supported:

- **`en`** — the single-language English policy (everything the project's AI produces is
  English).
- **`zh`** — the consumer-split Chinese policy (human-facing output in Chinese,
  agent/LLM-facing artifacts in English; the current canonical split).

The command rewrites **only** the three policy-bearing surfaces of the *target project*:

1. `.harness/rules/00-core.md` — the policy SECTION (heading-anchored).
2. `CLAUDE.md` — the single top policy LINE.
3. `.github/copilot-instructions.md` — the single top policy LINE.

Nothing else in the project changes. It is non-destructive (a `.bak` precedes every edit;
a clean git tree is required so `git reset` is a full rollback), idempotent (a second run
on an already-current project is a clean no-op), and reversible (`en` -> `zh` -> `en`
restores the exact original bytes, because all text is pulled from the plugin templates).

> This skill is the **judgment layer**. All mechanical work — locating the policy section
> by its canonical heading, slicing it, substituting the canonical block, swapping the
> one-line policy, writing the `.bak`, the byte-identity NOOP — is done by one
> deterministic helper, `language-policy.sh`, which the skill bootstraps from the
> plugin template cache and drives with explicit flags. The skill does NO markdown
> string-replacement and embeds NO policy text itself.

## When to invoke

- `/harness-language en` — make the project English-only.
- `/harness-language zh` — make the project use the consumer-split Chinese policy.
- `/harness-language` (no arg) — **refresh** the project's CURRENT language to the latest
  canonical text (useful for an old project initialized before the policy was refined).
- For a layout/version upgrade (scripts, hooks, verify_all) → use `/harness-upgrade`.
- For a brand-new project → use `/harness-init` (it asks the language at init).

## Procedure

Use `TodoWrite` to track. Stages are gated: never apply without an explicit user "yes".

### 1. Target & precondition gate

The current working directory is the target project.

- Confirm `.git/` exists. If not → **halt**, no changes ("not a git repository").
- Refuse on a **dirty working tree** (`git status --porcelain` non-empty) with "commit or
  stash your changes first" — this preserves the `git reset` rollback path. (The helper's
  `.bak` covers any untracked policy surface.)
- Confirm at least one of `.harness/rules/00-core.md` OR `CLAUDE.md` exists. If **neither**
  → **halt**, point the user at `/harness-init` (empty project) or `/harness-adopt`
  (no-harness project): "this project has no language-policy surface to operate on".

### 2. Validate the argument

- If an argument is present and is not `en` or `zh` → **halt** ("only en|zh are
  supported"), change nothing.

### 3. Locate the plugin template cache + read the target version

Resolve the plugin template root, in this order (first hit wins) — identical to
`/harness-upgrade`:

1. **`$CLAUDE_PLUGIN_ROOT`** if set → `$CLAUDE_PLUGIN_ROOT/skills/harness-init/templates`.
   Best-effort only; if unset, fall through — do NOT depend on it.
2. **Versioned plugin cache glob (load-bearing):**
   `~/.claude/plugins/cache/harness-kit-marketplace/harness-kit/*/skills/harness-init/templates`.
   On multiple matches pick the **highest semver** directory.
3. **Dev / marketplace-less fallbacks:**
   `~/.claude/plugins/cache/*/harness-kit/*/skills/harness-init/templates`, then
   `~/.claude/skills/harness-init/templates`.
4. **None resolve → halt** ("could not locate the harness-kit plugin template cache;
   reinstall the plugin"). The helper is never invoked.

The helper's `--template-root` is the directory **above** `skills/harness-init/templates`
— the resolved cache root `<cache>/harness-kit/<version>/` (the directory that contains
`skills/`). Read `<that>/.claude-plugin/plugin.json` `version` and surface it in the plan
as human prose ("Target policy version: x.y.z").

> The helper does ZERO cache discovery — discovery is judgment, so it stays in this AI
> layer. The helper is a pure deterministic transform driven by `--template-root`. The
> canonical policy text is read ONLY from the resolved templates, never fabricated and
> never sourced from the target project — so a stale project that does not already contain
> the canonical text still gets the correct target text.

### 4. Determine the target language (detect-then-ASK; never silently guess)

- **Explicit `en`/`zh`** → that is the target. Detection still runs (to report "switching
  from <X> to <Y>" or "already <Y>"), but the choice is fixed by the argument.
- **No-arg refresh** → you have no language yet, but the helper REQUIRES `--lang`. To read
  the current language WITHOUT changing anything, invoke the helper with a placeholder
  `--lang <either en|zh> --dry-run` purely to capture the `DETECT|<lang>|<source>` record
  from stdout — the helper emits `DETECT|...` unconditionally after arg-validation and
  before any mutation, and `--dry-run` writes nothing, so the placeholder language is
  inert. Then **confirm the detected language with `AskUserQuestion`**, pre-filled:
  "Detected `<lang>`. Refresh to the current canonical `<lang>` policy? [yes / switch to
  the other language / cancel]". The confirmed value becomes the real `--lang` from step 5.
- **Ambiguous** (`DETECT|ambiguous|...`: conflicting sources or no recognizable policy
  surface) → `AskUserQuestion` with **no pre-filled default** ("Could not determine the
  current language. Set it to: [en / zh / cancel]"). Never guess.

Detection order (the helper computes it): `.harness/rules/00-core.md` policy heading →
`CLAUDE.md` top policy line → `.github/copilot-instructions.md` top policy line; first
confident hit wins.

### 5. Plan (dry-run) → present → confirm → apply

1. Invoke the helper with `--dry-run`:

   ```
   bash <root>/.harness/scripts/language-policy.sh --template-root <abs> --lang <en|zh> --dry-run
   ```

   (Drive whichever copy is present in the target project's `.harness/scripts/`; if the
   project has no `language-policy.*` yet, copy it from
   `<template-root>/skills/harness-init/templates/common/.harness/scripts/` first — the
   same self-bootstrap `/harness-upgrade` does for its helper.)

From Alan-IFT/harness-kit, MIT.

More from Alan-IFT/harness-kit