---
name: ssp-interview
description: Interview-driven SSP authoring command. Greenfield gathering — no inputs/ files required. Six-phase pipeline (interview → review → user-edit loop → compose→apply via the halo-action-pipeline), same downstream phases as /ssp-ingest but with ssp-interviewer driving Phases 0-3 instead of ssp-curator. Use when authoring an SSP from scratch through conversation, OR when extending an existing SSP per-Capability without uploaded source documents. Load when the user runs /ssp-interview, asks to "interview me for the SSP", "gather SSP content by chat", "walk through Phase 0", or "add the IAM Capability via interview".
---

# ssp-interview — Interview-driven SSP authoring

Conversational counterpart to `/ssp-ingest`. Where `/ssp-ingest` reads `inputs/` files, `/ssp-interview` asks the user open-ended questions in chat and structures the responses into draft SSP content. Both share the same downstream phases — review, user-edit loop, writer.

## References

| Reference | Type | Location | When to Use |
|---|---|---|---|
| `ssp-ingest` | Skill | `plugins/grcitsm-analyst/skills/ssp-ingest/` | File-driven counterpart — shared downstream phases (review, user-edit, writer) |
| `ssp-review-standards` | Skill | `plugins/grcitsm-analyst/skills/ssp-review-standards/` | Phase 4 reviewer discipline applied to interview output |
| `ssp-brand-voice` | Skill | `plugins/grcitsm-analyst/skills/ssp-brand-voice/` | Voice rules the interviewer drafts narrative in |
| `ssp-capability-seed-list` | Skill | `plugins/grcitsm-analyst/skills/ssp-capability-seed-list/` | The 15 anchor Capabilities for per-Capability interview mode |
| `ssp` | Skill | `plugins/grcitsm-analyst/skills/ssp/` | SSP asset workflow primer |
| `halo-ssp-asset-model` | Skill | `plugins/grcitsm-analyst/skills/halo-ssp-asset-model/` | Field schema for the asset types the interview populates |
| `grcitsm` | Skill | `plugins/grcitsm-analyst/skills/grcitsm/` | Halo MCP catalog read tools used during interview reconciliation |

## When to load this skill

- User types `/ssp-interview` (with or without flags).
- User asks to "interview me for the SSP", "walk through Phase 0", "gather SSP content by chat", "add the IAM Capability via interview", "start the SSP rebuild".
- `inputs/` is empty or doesn't contain documents relevant to the target Capability / Phase.

## Site targeting

Same as `/ssp-ingest`: `--site-id N` or `--client-name "X"`. See [[ssp-ingest]] § Site targeting.

## Mode flags

| Flag | Mode | What runs |
|---|---|---|
| `--phase 0` | Phase 0 — system_information refresh | ssp-interviewer walks the 4 narrative blocks (General Description, Authorization Boundary, Network Architecture, Data Flow) + structural fields (Impact Level, DIL, Service Model, etc.) |
| `--capability "X"` | Per-Capability gathering | ssp-interviewer walks the Capability scope → Components → Implemented Requirements (per-control) → Implementation Statements (per Component × control) for one Capability from [[ssp-capability-seed-list]] (or a tenant-specific one) |
| `--additive` | Extend existing | ssp-interviewer reads current Halo state for the target scope, asks only about gaps |
| (no flag) | Auto-detect | If system_information narratives are empty → Phase 0; else prompt the user which Capability to interview |

## The 6 phases

Same pipeline as `/ssp-ingest`. Only the first phase differs (interviewer vs curator):

```
1. INTERVIEW         (ssp-interviewer agent)
   Conversational gathering: open-ended questions, prose drafting,
   inline-render in chat for real-time user reaction.
   Emits: interview-notes.md + change-plan-fragment-{phase}.jsonl

2. (no extract — interviewer drafts prose directly)
3. (no reconcile — interviewer reads live state during the interview)
4. REVIEW            (ssp-reviewer agent)
   Internal review loop: BLOCKER detection + AUTO-FIX application,
   max 5 passes, halt on unresolvable BLOCKERs.

5. USER-EDIT LOOP    (main agent coordinating)
   Render polished draft → user approves / edits / cancels.
   On edits: mutate, re-review (Phase 4), re-render.
   Loop until approve.

6. COMPOSE → APPLY   (main agent orchestrating; shared with /ssp-ingest)
   Project the approved plan's structural rows into CSV manifests
   (this path has no Phase-3 projection) → reconcile_ssp_assets →
   ssp_compile.py → ssp-writer composes residual actions →
   /grcitsm-analyst:halo-apply → relationship reconcilers → verify.
   Full sequence: reference-docs/ssp-ingest-phases.md § Phase 6.
```

Phases 2-3 from `/ssp-ingest` are merged into Phase 1 here — the interviewer drafts prose directly rather than extracting from files and reconciling.

## What the user sees per phase

- **Phase 1:** open-ended chat questions, draft prose rendered inline as it's gathered, conversational iteration before formal Phase 4 review.
- **Phase 4:** invisible — internal review loop runs without surfacing intermediate state.
- **Phase 5:** polished CHANGE-PLAN draft in chat, with the prompt: `Approve and write to Halo? Or describe edits you want, and I'll re-render.`
- **Phase 6:** compile/compose summary, apply progress from the `state/progress.jsonl` ledger, then the verify-pass summary of what landed.

## Output folder layout

```
outputs/ssp-interview-{date}-{run-id}/
  interview-notes.md             # Phase 1 — every Q+A captured
  change-plan-fragment-{phase}.jsonl  # Phase 1 — draft rows per interview block
  change-plan.md                 # Phase 4+ — current polished plan (overwritten each iteration)
  change-plan.jsonl              # Phase 4+ — machine-readable form Phase 6 consumes
  review-log.md                  # Phase 4 — AUTO-FIX audit
  blockers.md                    # Phase 4 — present only if loop halts on BLOCKERs
  user-iterations.md             # Phase 5 — per-iteration user feedback + mutations
  manifests/*.csv                # Phase 6 — structural projection of the approved plan (compile input)
  state/actions-*.jsonl          # Phase 6 — compiled + composed action files
  state/progress.jsonl           # Phase 6 — append-only apply ledger (the resume surface)
  uuid-map.jsonl                 # Phase 6 — AFUUID → asset_id, projected from the ledger
```

Run-id increments per run on the same date.

## Run state files

Every run produces a `state.json` pointer file plus the slice files listed above. The state-file convention — schema, update cadence, atomic writes, resume discipline — is defined in `reference-docs/ssp-run-state.md`. Every agent in the pipeline reads `state.json` at start and updates it (atomically) at every transition. The user can interrupt any run, return later, and resume from `next_action`.

## Cross-references

- [[ssp-ingest]] — file-driven counterpart.
- [[ssp-review-standards]] — Phase 4 discipline.
- [[ssp-brand-voice]] — voice the interviewer drafts in.
- [[ssp-capability-seed-list]] — the 15 (anchor for per-Capability mode).
- [[ssp]] — SSP asset workflow primer.
- [[halo-ssp-asset-model]] — field schema.
- [[grcitsm]] — Halo MCP catalog.

## Sub-agents this skill orchestrates

- `ssp-interviewer` — Phase 1.
- `ssp-reviewer` — Phase 4 (every outer-loop iteration).
- `ssp-writer` — Phase 6 residual composer (after explicit user approval; the apply itself is `/grcitsm-analyst:halo-apply`).
