/printing-press-reprint

name: printing-press-reprint
description: >
  Regenerate an existing printed CLI from scratch under the current Printing
  Press, with prior research, prior novel features, and prior patches
  (post-publish hand-fixes) carried into the writing pipeline as
  reconciliation context rather than dropped on the floor. Pulls the CLI
  from the public library if it isn't local, recommends reuse-vs-redo of
  prior research based on age, then hands off to /printing-press with the
  right context. Use when a machine upgrade would benefit a published CLI
  more than manual polish.
  Trigger phrases: "reprint <api>", "regenerate <api>", "redo the <api> CLI",
  "rebuild <api> from scratch", "this CLI would benefit from a reprint".
allowed-tools:
  - Bash
  - Read
  - AskUserQuestion
  - Skill
created_by: user

/printing-press-reprint

Regenerate an existing printed CLI under the current machine. The user gives a CLI name and (optionally) reasons for the reprint. This skill ensures the prior CLI is locally present, recommends whether to reuse or redo prior research, and hands off to `/printing-press` with the context the novel-features subagent needs to reconcile prior features against the current machine — keep, reframe, or drop with reasons, never silent.

/printing-press-reprint notion
/printing-press-reprint cal.com  the new MCP intent surface landed and the prior CLI ships endpoint-mirror only
/printing-press-reprint allrecipes

When to run

• A significant Printing Press upgrade (new MCP surface, new auth modes, new

transport, scoring rubric changes) would lift this CLI more than manual polish.

• The published CLI ships with a known systemic gap a reprint would fix.
• The user wants prior novel features re-evaluated against the current

machine and current personas, not carried forward verbatim.

For one-off code-quality fixes, prefer `/printing-press-polish` — it doesn't redo research or rebuild the manuscript.

Setup

PRESS_HOME="${PRINTING_PRESS_HOME:-$HOME/printing-press}"
PRESS_LIBRARY="$PRESS_HOME/library"
PRESS_MANUSCRIPTS="$PRESS_HOME/manuscripts"

# Mid-pipeline callers may pass printing_press_bin: <abs-path> in the args
# bundle. Prefer it so reprint keeps using the parent skill's preflight-selected
# binary instead of re-resolving through PATH.
PRINTING_PRESS_BIN="${PRINTING_PRESS_BIN:-}"
if [ -z "$PRINTING_PRESS_BIN" ] && [ -n "${ARGUMENTS:-}" ]; then
  PRINTING_PRESS_BIN="$(printf '%s\n' "$ARGUMENTS" | sed -nE 's/^[[:space:]]*printing_press_bin:[[:space:]]*(.+)$/\1/p' | head -1)"
fi
if [ -z "$PRINTING_PRESS_BIN" ]; then
  PRINTING_PRESS_BIN="$(command -v cli-printing-press 2>/dev/null || true)"
fi

if [ -z "$PRINTING_PRESS_BIN" ]; then
  echo "cli-printing-press binary not found."
  echo "Install with:  go install github.com/mvanhorn/cli-printing-press/v4/cmd/cli-printing-press@latest"
  return 1 2>/dev/null || exit 1
fi
echo "PRINTING_PRESS_BIN=$PRINTING_PRESS_BIN"

Phase A — Resolve and reconcile presence

Resolve the user's argument the same way `/printing-press-import` does: fetch the public library `registry.json` once, then exact → normalized → fuzzy match. The argument can be an API slug (`notion`), a brand name (`cal.com`), an old `<api>-pp-cli` form, or close enough.

Capture from the matched registry entry: `API_SLUG` (from `.name`) and `LIB_PATH` (from `.path`, e.g., `library/productivity/cal-com`). Phase B uses `$LIB_PATH` for the public patches fetch. For the "present | absent" never-published row, `$LIB_PATH` stays empty — Phase B's fetch short-circuits on that.

Then check what exists locally and reconcile against the public library by reading both provenance manifests' `run_id` and `generated_at`:

| Local | Public registry | Action | |-------|-----------------|--------| | absent | absent | STOP — nothing to reprint; suggest `/printing-press <api>` for a fresh print | | absent | present | invoke `/printing-press-import <api>`, then continue | | present | absent | continue — never-published local CLI; skip import | | present, same `run_id` | present | continue without import | | present, public newer `generated_at` | present | offer import via `AskUserQuestion`; user decides | | present, local newer `generated_at` | present | STOP — local has unpublished work; tell user to publish or discard first |

When invoking `/printing-press-import`, let it own backup, overwrite, build-verify, and module-path-rewrite. Wait for it to return clean before continuing.

Phase B — Verify reconcilable prior context

Locate the two artifacts the writing pipeline should be aware of: research (drives novel-features Pass 2(d)) and patches (post-publish hand-fixes recorded by `/printing-press-amend`, e.g. live-discovered API quirks the spec didn't reveal).

LIB_TARGET="$PRESS_LIBRARY/$API_SLUG"
LIB_RESEARCH="$LIB_TARGET/research.json"
MAN_RESEARCH=$(ls -1t "$PRESS_MANUSCRIPTS/$API_SLUG"/*/research.json 2>/dev/null | head -1)

Research absent

If neither research path exists, the published CLI predates `research.json` provenance. The subagent will treat the run as a first print and Pass 2(d) reprint reconciliation will not fire — there is nothing for it to read. Surface this and ask:

> Published `<api>` was built before `research.json` provenance landed. > Without it, the novel-features subagent will treat this as a first > print — there is nothing to reconcile against. Continue as a degraded > reprint (essentially a fresh print with a kept binary name)?

If the user declines, exit. If they continue, record the absence so the hand-off prompt notes that this is a degraded reprint.

Patches discovery

Refresh the local patches index from public when reachable, then read locally so downstream references are durable. Amends may have landed against the public copy without triggering a regen, so the local copy can lag even when `run_id` matches; this step closes that gap.

The index ships in one of two shapes: the per-patch di