/proposal-create

name: proposal-create
description: Creates a proposal for a high-leverage improvement discovered during work. Only for ideas with real impact — not trivial fixes. Use when you discover something worth operationalizing.

Record notes only inside an open record's turn, using `bun ${CLAUDE_PLUGIN_ROOT}/scripts/task.ts note .claude-code-hermit <id>` with the note on stdin. Otherwise skip record notes. Never edit a task file directly.

Create Proposal

**Options:** `--no-artifacts` (alias `--no-artifact`) skips the final artifact refreshes and artifact URL announcement. Useful for batches or callers that refresh afterward.

Create a proposal only when you discover something with real leverage:

• A missing helper or utility that would save significant time across sessions
• A missing validation or guardrail that could prevent real errors
• A workflow improvement that would benefit multiple sessions
• A reusable pattern worth operationalizing

A routine invoking `reflect --check-id <id> --check <namespaced skill>` supplies findings through the normal judge and triage gates with `Evidence Source: scheduled-check/<id>` and `Sessions: none`. Preserve that provenance when creating the proposal.

Three-Condition Rule

Only create a proposal if all three are true: 1. **Repeated pattern** — observed more than once, across sessions. Recurrence is already verified upstream for every evidence source except `archived-session` (by the routine-invoked check's own analysis, the `reflection-judge`, the brainstorm pass, a cited `state/observations.jsonl` graduation, or a cited machine-written state file with the measured values), so re-establish it here only for `archived-session` candidates. Procedure-capture candidates meeting the ephemerality exception (ephemeral artifacts + quantified cost, single current session) also count (see reflect § Procedure capture). 2. **Meaningful consequence** — something goes wrong without fixing it 3. **Operator-actionable change** — something the operator can concretely approve

If any applicable condition cannot be stated concretely, do not create the proposal. Respond: "Not enough evidence yet. Note it in open record notes and revisit after more sessions."

Pre-Creation Gate

Pin the hermit root before dispatching:

bun ${CLAUDE_PLUGIN_ROOT}/scripts/proposal.ts anchor .claude-code-hermit

Its stdout is one whole `Anchor: root=… memory_dir=…` line, already carrying the `Anchor:` prefix — paste it verbatim as the first line of the agent prompt, do not re-prefix it. On a non-zero exit there is no line to paste: do not dispatch, rerun with the absolute state dir the error names in place of `.claude-code-hermit`.

Before creating the proposal, call `claude-code-hermit:proposal-triage`. Pass `Evidence Source:` and `Evidence Origin:` when known:

Anchor: root=<absolute hermit root> memory_dir=<absolute auto-memory dir>
Title: <proposal title>
Evidence Source: <archived-session | current-session | scheduled-check/<id> | operator-request | capability-brainstorm>
Evidence Origin: <own-work | external-content>
Evidence: <one-paragraph evidence summary>

`Evidence Source:` is optional (default: `archived-session`). `Evidence Origin:` is optional (default: `own-work`).

This is a single-candidate call (a batch of one), so the response is one verdict block. Lines 2+ are additive metadata (`closest_prop`, `aligned`, `operator_excerpt`, `overlap_compiled`, `prior_discussion`, `failed_condition`) — read for context if useful but do not branch on them. Record line 1 as the verdict:

bun ${CLAUDE_PLUGIN_ROOT}/scripts/proposal.ts gate .claude-code-hermit --gate triage --caller proposal-create \
    --evidence-source "<evidence source>" --tags '[<caller-supplied tags>]' <<'HERMIT_GATE'
Title: <proposal title>
Verdict: <the agent's line 1, verbatim>
HERMIT_GATE

`evidence_source` is the `Evidence Source:` value the caller passed (default `archived-session`). `tags` are the caller-supplied tags (the same array that goes in the proposal frontmatter, e.g. `["procedure-capture"]`); use `[]` if none. Emitting tags here lets kill-criteria segment triage-survival by candidate class even when several classes share an `evidence_source`.

• `PROCEED|CREATE` — proceed with the steps below
• `DROP|DUPLICATE:<PROP-ID>` — stop, report to the caller: "Proposal already exists as <PROP-ID>"
• `DROP|SUPPRESS:<code>` — stop, report the suppression reason (from the agent's line 1) to the caller
• `GATE_FAILED` (unrecognized/empty line 1 — agent errored, returned malformed output, or was terminated before emitting a verdict): fail closed — do not create the proposal. When inside an open task record turn, note it with the record id; otherwise report it to the caller:

  bun ${CLAUDE_PLUGIN_ROOT}/scripts/task.ts note .claude-code-hermit <id> <<'HERMIT_LINE'
  gate-failed: proposal-triage — <title> — <the agent's line 1, verbatim>
  HERMIT_LINE

The candidate re-surfaces on the next reflect cycle.

How to Create

Call `proposal.ts create` with the full proposal as one heredoc — header lines, a bare `---` separator, then the raw markdown body:

bun ${CLAUDE_PLUGIN_ROOT}/scripts/proposal.ts create .claude-code-hermit <<'HERMIT_PROPOSAL'
Title: <proposal title>
Source: manual
Session: T-...
Category: improvement
Tags: ["tag-1","tag-2"]
Related-Sessions: []
Findings: <optional one-line summary>
---
## Context
<clear description>

## Problem
<what's wrong or missing>

## Proposed Solution
<concrete steps>

## Impact
<effort vs benefit>

## Verification
<how this will be checked>

## References
<sources, or "n/a — <reason>">

## Success Signal
<predicate, or an HTML comment explaining why none>

## Operator Decision
HERMIT_PROPOSAL

The script assigns the canonical ID `PROP-NNN-<slug>-HHMMSS` (resolves the next `NNN`, generates the slug, stamps `HHMMSS` in `config.json`'s timezone, claims it atomically with a same-second collision-suffix letter on conf