@gillcash/necktie 0.2.0

package/hooks/necktie-context.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+function pluginRoot(env = process.env) {
+  return env.PLUGIN_ROOT || env.CLAUDE_PLUGIN_ROOT || path.resolve(__dirname, "..");
+}
+
+function coreContext(env = process.env) {
+  return fs.readFileSync(path.join(pluginRoot(env), "core", "necktie-core.md"), "utf8").trim();
+}
+
+function host(env = process.env) {
+  const compatibilityRoot = env.CLAUDE_PLUGIN_ROOT || "";
+  if (env.COPILOT_PLUGIN_DATA || compatibilityRoot.includes(".vscode/agent-plugins")) return "copilot";
+  if (env.QODER_SESSION_ID) return "qoder";
+  if (env.PLUGIN_ROOT || env.PLUGIN_DATA) return "codex";
+  return "claude";
+}
+
+function payload(event, env = process.env, explicitHost = "") {
+  const context = coreContext(env);
+  const detected = explicitHost || host(env);
+  if (detected === "copilot") return { additionalContext: context };
+  if (detected === "codex" || detected === "qoder" || detected === "gemini" || event === "SubagentStart") {
+    return { hookSpecificOutput: { hookEventName: event, additionalContext: context } };
+  }
+  return context;
+}
+
+function main(argv = process.argv.slice(2), env = process.env) {
+  const event = argv[0] || "SessionStart";
+  const hint = argv[1] || "";
+  const explicitHost = hint === "copilot" || hint === "qoder" ? hint : hint ? "gemini" : "";
+  const result = payload(event, env, explicitHost);
+  process.stdout.write(typeof result === "string" ? result : JSON.stringify(result));
+}
+
+if (require.main === module) main();
+
+module.exports = { coreContext, host, main, payload, pluginRoot };

package/hooks/qoder-hooks.json

@@ -0,0 +1,26 @@
+{
+  "_comment": "Copy the hooks object into Qoder settings and replace NECKTIE_DIR with the absolute path to this checkout.",
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"NECKTIE_DIR/hooks/necktie-context.js\" UserPromptSubmit qoder"
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "task|Task",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"NECKTIE_DIR/hooks/necktie-context.js\" SubagentStart qoder"
+          }
+        ]
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@gillcash/necktie",
+  "version": "0.2.0",
+  "description": "The angel of late-stage capitalism for your AI agent: an always-on response check and an explicit bounded review loop.",
+  "keywords": ["agent-plugin", "agent-loop", "prompt-reversal", "review", "verification"],
+  "license": "MIT",
+  "author": {
+    "name": "gillcash",
+    "url": "https://github.com/gillcash"
+  },
+  "homepage": "https://github.com/gillcash/necktie",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gillcash/necktie.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gillcash/necktie/issues"
+  },
+  "main": "./.opencode/plugins/necktie.mjs",
+  "exports": {
+    ".": "./.opencode/plugins/necktie.mjs",
+    "./plugin": "./.opencode/plugins/necktie.mjs"
+  },
+  "files": [
+    "AGENTS.md",
+    "plugin.json",
+    "core/",
+    "hooks/",
+    "skills/",
+    "commands/",
+    ".opencode/",
+    ".qoder/",
+    ".qoder-plugin/",
+    "pi-extension/",
+    "assets/",
+    "LICENSE",
+    "NOTICE",
+    "!**/__pycache__/**",
+    "!**/*.pyc",
+    "!pi-extension/test/**"
+  ],
+  "scripts": {
+    "build:adapters": "node scripts/build-adapters.js && node scripts/build-openclaw-skills.js",
+    "check:adapters": "node scripts/build-adapters.js --check",
+    "check:versions": "node scripts/check-versions.js",
+    "test": "npm run check:adapters && npm run check:versions && node --test tests/*.test.js tests/*.test.mjs && npm test --prefix pi-extension && npm test --prefix necktie-mcp && python -m unittest discover -s tests -p test_*.py"
+  },
+  "pi": {
+    "extensions": ["./pi-extension/index.js"],
+    "skills": ["./skills"]
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/pi-extension/index.js

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export function coreContext() {
+  return fs.readFileSync(path.resolve(__dirname, "..", "core", "necktie-core.md"), "utf8").trim();
+}
+
+export function sendSkill(pi, skill, args, ctx) {
+  const suffix = String(args || "").trim();
+  const message = suffix ? `/skill:${skill} ${suffix}` : `/skill:${skill}`;
+  if (ctx?.isIdle?.() === false) pi.sendUserMessage(message, { deliverAs: "followUp" });
+  else pi.sendUserMessage(message);
+}
+
+export default function necktieExtension(pi) {
+  for (const skill of ["necktie", "necktie-critique", "necktie-reverse", "necktie-review"]) {
+    pi.registerCommand(skill, {
+      description: `Run /skill:${skill}`,
+      handler: (args, ctx) => sendSkill(pi, skill, args, ctx),
+    });
+  }
+  pi.on("before_agent_start", async (event) => {
+    const base = event?.systemPrompt ? `${event.systemPrompt}\n\n` : "";
+    return { systemPrompt: `${base}${coreContext()}` };
+  });
+}

package/pi-extension/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@gillcash/necktie-pi-extension",
+  "version": "0.2.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  }
+}

package/plugin.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "necktie",
+  "version": "0.2.0",
+  "description": "The angel of late-stage capitalism for your AI agent: an always-on response check and an explicit bounded review loop.",
+  "author": {
+    "name": "gillcash",
+    "url": "https://github.com/gillcash"
+  },
+  "homepage": "https://github.com/gillcash/necktie",
+  "repository": "https://github.com/gillcash/necktie",
+  "license": "MIT",
+  "keywords": ["agent-loop", "prompt-reversal", "review", "verification"]
+}

package/skills/necktie/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: necktie
+description: Run a goal from raw context to a reviewed, verified final deliverable through the explicit, bounded Necktie Loop. Use when the user invokes /necktie, $necktie, or @necktie; asks to reverse-engineer an iterative conversation into one reusable prompt; wants an independent critique and review gate; or explicitly requests the Necktie workflow.
+---
+
+# Necktie
+
+*the angel of late-stage capitalism for your AI agent*
+
+Turn an underspecified or iterative request into one evidence-grounded deliverable and a reusable execution brief. Separate method context from domain evidence, critique the inquiry before optimizing the answer, and stop only at a verified result, a material blocker, or the circuit breaker.
+
+## Start the run
+
+1. Treat the text following `/necktie` or `$necktie` as the goal and any attached files, links, or named paths as candidate sources.
+2. Read [references/loop-protocol.md](references/loop-protocol.md) completely before running the loop.
+3. Maintain a compact run packet in memory. When the user requests an audit trail, resumability, or files, initialize `.necktie/run.json` with `scripts/necktie_loop.py` and update it at phase boundaries.
+4. Ask a question only when the answer would materially change the objective, evidence, authority, or deliverable. Otherwise record the assumption and proceed.
+
+## Run the loop
+
+### 1. Frame
+
+State the outcome, intended audience, acceptance criteria, constraints, and non-goals. Build a source ledger that labels every input as one of:
+
+- `evidence`: may support claims in the final output.
+- `method`: controls how to work but does not prove domain claims.
+- `constraint`: governs scope, format, safety, or authority.
+- `prior-output`: useful as a hypothesis or preference, not independent evidence.
+
+### 2. Establish a baseline
+
+Inspect the relevant sources and sketch the smallest plausible answer or approach. Record its assumptions and known weaknesses. Do not polish it into the final artifact yet.
+
+### 3. Critique
+
+Apply the `$necktie-critique` skill to the goal, baseline, source ledger, and acceptance criteria. Require it to challenge the framing, identify what the user may have overlooked relative to the goal, name the strongest unasked expert question, and distinguish material questions from optional improvements.
+
+### 4. Reverse
+
+Resolve critique findings with evidence or explicit assumptions. Then apply `$necktie-reverse` to compile the complete successful trajectory into one executable brief. The brief must be usable in a fresh session without relying on hidden conversation state.
+
+### 5. Execute
+
+Produce the requested artifact from the executable brief and the raw evidence sources. Do not treat the baseline, critique, or previous answer as proof. Follow any applicable artifact skill and perform proportional checks while building.
+
+### 6. Review
+
+Apply `$necktie-review` with the exact executable brief, candidate artifact, acceptance criteria, source ledger, and compact evidence packet. Use a separate reviewer agent when the host supports it and policy permits; otherwise perform a fresh-context review that does not edit the artifact while judging it.
+
+Handle the decision exactly:
+
+- `APPROVE`: proceed to verification.
+- `REVISE`: fix the cited material findings, then return the changed artifact to review.
+- `BLOCK`: stop and report the missing evidence, authority, or user decision.
+
+Never route around a reviewer denial by restating the same action. Stop after three revision decisions or after three consecutive reviews with the same unresolved issue.
+
+### 7. Verify
+
+Test, render, calculate, inspect, or otherwise exercise the artifact in the environment where it will be used. If verification exposes a material defect and budget remains, revise and review again. Otherwise block with the concrete failure.
+
+Deliver:
+
+1. The final artifact or a precise link/path to it.
+2. The reusable executable brief.
+3. A concise verification record and any limitations.
+4. What the user may not have considered, if material.
+5. The strongest unasked question, with its practical consequence.
+
+Do not reveal private chain-of-thought. Provide concise decisions, evidence, assumptions, and test results instead.
+
+## Use the minimum sufficient intervention
+
+At every phase, prefer the earliest option that meets the acceptance criteria:
+
+1. Do not create anything if explanation or a decision is enough.
+2. Reuse a trusted existing asset.
+3. Use the host's built-in capability or an installed skill.
+4. Use standard-library automation.
+5. Add the smallest new implementation.
+
+Do not expand scope merely because the loop discovers an attractive adjacent task.
+
+## Audit the state machine
+
+Use the bundled controller only when persistence is useful:
+
+```text
+python skills/necktie/scripts/necktie_loop.py init --goal "..." --output .necktie/run.json
+python skills/necktie/scripts/necktie_loop.py transition --file .necktie/run.json --to baseline --note "Sources classified"
+python skills/necktie/scripts/necktie_loop.py review --file .necktie/run.json --decision REVISE --reason "Unsupported claim" --issue-signature evidence-gap
+python skills/necktie/scripts/necktie_loop.py show --file .necktie/run.json
+```
+
+The controller records decisions, not hidden reasoning. It enforces valid transitions and the review circuit breaker; it does not generate or judge the artifact.

package/skills/necktie/agents/openai.yaml

@@ -0,0 +1,6 @@
+interface:
+  display_name: "Necktie"
+  short_description: "the angel of late-stage capitalism for your AI agent"
+  default_prompt: "Use $necktie to turn this goal into a reviewed, verified final deliverable."
+policy:
+  allow_implicit_invocation: false

package/skills/necktie/references/loop-protocol.md

@@ -0,0 +1,85 @@
+# Necktie loop protocol
+
+## Purpose
+
+Use this protocol to transform an initial request and its source context into a reusable brief and a verified final artifact. The loop combines prompt reversal, inquiry critique, blueprint-first execution, independent review, and a finite circuit breaker.
+
+## State model
+
+```text
+frame -> baseline -> critique -> reverse -> execute -> review
+                                                  ^         |
+                                                  |         v
+                                                revise <- REVISE
+                                                            |
+                                        APPROVE -> verify -> complete
+                                                            |
+                                        BLOCK  ----------> blocked
+```
+
+Verification failure returns to `revise` only while review budget remains. A blocked run resumes only when new evidence, authority, or a material user decision changes the conditions.
+
+## Run packet
+
+Maintain only information needed to reproduce and audit decisions:
+
+```json
+{
+  "goal": "Desired real-world outcome",
+  "state": "frame",
+  "audience": "Who will use the result",
+  "deliverables": [],
+  "acceptance_criteria": [],
+  "constraints": [],
+  "non_goals": [],
+  "sources": [
+    {"id": "S1", "kind": "evidence", "location": "...", "use": "..."}
+  ],
+  "assumptions": [],
+  "strongest_unasked_question": "",
+  "review_history": [],
+  "verification": []
+}
+```
+
+Do not store secrets or private reasoning. Record concise rationales, citations, hashes, commands, or test results when useful.
+
+## Role separation
+
+The author creates and revises. The critic challenges the inquiry before execution. The reviewer judges the exact candidate after execution. Prefer separate agent contexts when the host provides them, but never broaden permissions or expose more evidence than the role requires.
+
+If only one agent is available, emulate separation by finishing and freezing the author packet, then starting a read-only review pass from the exact brief and evidence index. Do not edit until the decision has been recorded.
+
+## Source discipline
+
+- `evidence` supports domain claims.
+- `method` describes how to reason or work.
+- `constraint` controls behavior, authority, scope, or form.
+- `prior-output` preserves preferences or hypotheses but cannot corroborate itself.
+
+When executing the reversed brief, return to raw evidence rather than paraphrasing the baseline. This prevents iterative wording from turning into false support.
+
+## Bounded improvement
+
+The loop permits at most three `REVISE` decisions.
+
+Open the circuit and block when any condition occurs:
+
+- the same issue signature survives three consecutive reviews;
+- three revision decisions have been recorded;
+- the next step needs new authority, unavailable evidence, or a material user choice;
+- further work would expand beyond the agreed goal.
+
+Do not evade a denial by renaming the same action or changing only its presentation. A new pass must make a material change tied to a finding.
+
+## Completion contract
+
+A run is complete only when:
+
+1. the artifact and executable brief exist;
+2. all critical and major findings are resolved;
+3. relevant verification passes in the target environment;
+4. remaining limitations are explicit;
+5. the handoff identifies the strongest unasked question when it could change future action.
+
+Necktie has no persistent operating mode. The run packet records one explicitly invoked loop; it does not turn Necktie Core on or off.

package/skills/necktie/scripts/necktie_loop.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""Create and advance an auditable, deterministic Necktie Loop packet."""
+
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import sys
+import uuid
+
+
+SCHEMA_VERSION = "2.0"
+REVISION_LIMIT = 3
+STATES = {
+    "frame", "baseline", "critique", "reverse", "execute", "review",
+    "revise", "verify", "complete", "blocked",
+}
+ALLOWED_TRANSITIONS = {
+    "frame": {"baseline"},
+    "baseline": {"critique"},
+    "critique": {"reverse"},
+    "reverse": {"execute"},
+    "execute": {"review"},
+    "revise": {"review"},
+    "verify": {"complete", "revise"},
+}
+
+
+class LoopError(ValueError):
+    """Raised for an invalid run packet or state transition."""
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def event(kind: str, **details: object) -> dict[str, object]:
+    return {"at": utc_now(), "kind": kind, **details}
+
+
+def new_packet(goal: str) -> dict[str, object]:
+    goal = goal.strip()
+    if not goal:
+        raise LoopError("goal must not be empty")
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "run_id": str(uuid.uuid4()),
+        "created_at": utc_now(),
+        "updated_at": utc_now(),
+        "goal": goal,
+        "state": "frame",
+        "audience": "",
+        "deliverables": [],
+        "acceptance_criteria": [],
+        "constraints": [],
+        "non_goals": [],
+        "sources": [],
+        "assumptions": [],
+        "strongest_unasked_question": "",
+        "review_history": [],
+        "verification": [],
+        "circuit_breaker": None,
+        "history": [event("initialized", state="frame")],
+    }
+
+
+def validate_packet(packet: object) -> dict[str, object]:
+    if not isinstance(packet, dict):
+        raise LoopError("run packet must be a JSON object")
+    required = {"schema_version", "run_id", "goal", "state", "review_history", "history"}
+    missing = sorted(required - packet.keys())
+    if missing:
+        raise LoopError(f"run packet is missing: {', '.join(missing)}")
+    if packet["schema_version"] != SCHEMA_VERSION:
+        raise LoopError(f"unsupported schema_version: {packet['schema_version']}")
+    if packet["state"] not in STATES:
+        raise LoopError(f"unsupported state: {packet['state']}")
+    if not isinstance(packet["review_history"], list) or not isinstance(packet["history"], list):
+        raise LoopError("review_history and history must be arrays")
+    return packet
+
+
+def load_packet(path: Path) -> dict[str, object]:
+    try:
+        return validate_packet(json.loads(path.read_text(encoding="utf-8")))
+    except FileNotFoundError as exc:
+        raise LoopError(f"run packet not found: {path}") from exc
+    except json.JSONDecodeError as exc:
+        raise LoopError(f"invalid JSON in {path}: {exc}") from exc
+
+
+def save_packet(path: Path, packet: dict[str, object]) -> None:
+    validate_packet(packet)
+    packet["updated_at"] = utc_now()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(json.dumps(packet, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    temporary.replace(path)
+
+
+def transition(packet: dict[str, object], target: str, note: str) -> None:
+    current = str(packet["state"])
+    if target not in ALLOWED_TRANSITIONS.get(current, set()):
+        allowed = ", ".join(sorted(ALLOWED_TRANSITIONS.get(current, set()))) or "none"
+        raise LoopError(f"cannot transition from {current} to {target}; allowed: {allowed}")
+    packet["state"] = target
+    packet["history"].append(event("transition", previous=current, state=target, note=note.strip()))
+
+
+def record_review(packet: dict[str, object], decision: str, reason: str, issue_signature: str) -> None:
+    if packet["state"] != "review":
+        raise LoopError(f"review decisions require state=review, found {packet['state']}")
+    decision = decision.upper()
+    if decision not in {"APPROVE", "REVISE", "BLOCK"}:
+        raise LoopError(f"unsupported review decision: {decision}")
+    reason = reason.strip()
+    if not reason:
+        raise LoopError("review reason must not be empty")
+    signature = issue_signature.strip()
+    if decision == "REVISE" and not signature:
+        raise LoopError("REVISE requires --issue-signature")
+
+    reviews = packet["review_history"]
+    reviews.append(event("review", attempt=len(reviews) + 1, decision=decision,
+                         reason=reason, issue_signature=signature))
+    if decision == "APPROVE":
+        packet["state"] = "verify"
+    elif decision == "BLOCK":
+        packet["state"] = "blocked"
+        packet["circuit_breaker"] = "reviewer-blocked"
+    else:
+        revision_count = sum(item["decision"] == "REVISE" for item in reviews)
+        same_issue_count = 0
+        for item in reversed(reviews):
+            if item["decision"] == "REVISE" and item["issue_signature"] == signature:
+                same_issue_count += 1
+            else:
+                break
+        if same_issue_count >= 3:
+            packet["state"] = "blocked"
+            packet["circuit_breaker"] = "same-issue-three-times"
+        elif revision_count >= REVISION_LIMIT:
+            packet["state"] = "blocked"
+            packet["circuit_breaker"] = "revision-limit-reached"
+        else:
+            packet["state"] = "revise"
+    packet["history"].append(event("review-decision", decision=decision,
+                                   state=packet["state"], reason=reason))
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    initialize = subparsers.add_parser("init", help="create a new run packet")
+    initialize.add_argument("--goal", required=True)
+    initialize.add_argument("--output", type=Path, required=True)
+    advance = subparsers.add_parser("transition", help="advance to an allowed state")
+    advance.add_argument("--file", type=Path, required=True)
+    advance.add_argument("--to", choices=sorted(STATES), required=True)
+    advance.add_argument("--note", default="")
+    review = subparsers.add_parser("review", help="record an independent review decision")
+    review.add_argument("--file", type=Path, required=True)
+    review.add_argument("--decision", choices=["APPROVE", "REVISE", "BLOCK"], required=True)
+    review.add_argument("--reason", required=True)
+    review.add_argument("--issue-signature", default="")
+    show = subparsers.add_parser("show", help="validate and print a run packet")
+    show.add_argument("--file", type=Path, required=True)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        if args.command == "init":
+            packet = new_packet(args.goal)
+            save_packet(args.output, packet)
+            print(f"initialized {packet['run_id']} at {args.output}")
+        elif args.command == "transition":
+            packet = load_packet(args.file)
+            transition(packet, args.to, args.note)
+            save_packet(args.file, packet)
+            print(f"state={packet['state']}")
+        elif args.command == "review":
+            packet = load_packet(args.file)
+            record_review(packet, args.decision, args.reason, args.issue_signature)
+            save_packet(args.file, packet)
+            print(f"state={packet['state']}")
+        else:
+            print(json.dumps(load_packet(args.file), indent=2, ensure_ascii=False))
+    except LoopError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/necktie-critique/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: necktie-critique
+description: Critique and expand an inquiry before execution by testing goal alignment, assumptions, omitted perspectives, and evidence needs. Use inside the Necktie loop or when the user asks what they overlooked, wants the strongest unasked expert question, requests a red-team of the framing, or needs material follow-up questions rather than a direct answer.
+---
+
+# Necktie Critique
+
+Critique the inquiry, not merely the current answer. Broaden the user's view without turning the task into an endless discovery interview.
+
+## Inputs
+
+Obtain the goal, intended audience, acceptance criteria, source ledger, constraints, and any baseline approach. If one is missing, infer it when safe and label the assumption.
+
+## Method
+
+1. Restate the actual decision or outcome in one sentence.
+2. Test whether the requested deliverable is a means to that outcome or has become the goal by accident.
+3. Check the baseline for hidden assumptions, missing stakeholders, incentives, failure modes, alternative explanations, data limitations, and implementation constraints.
+4. Identify contradictions between the goal, evidence, requested format, and available authority.
+5. Simulate the most relevant genuine subject-matter expert. Ask what that expert would need to know before trusting or acting on the result.
+6. Select the single strongest unasked question: the question whose answer would most change the plan, conclusion, or risk.
+7. Separate questions into:
+   - `material-now`: execution should pause because different answers produce meaningfully different outputs.
+   - `assumption-safe`: proceed under a clearly stated default.
+   - `optional-later`: useful but outside the current scope.
+8. Reframe the inquiry so it targets the user's outcome, includes the necessary controls, and remains answerable from the permitted sources.
+
+Do not invent domain facts, confuse method guidance with evidence, or criticize stylistic preferences that do not affect the goal.
+
+## Output
+
+Return this compact structure:
+
+```text
+Outcome test: ...
+What is missing or misframed:
+- ...
+Assumptions to expose:
+- ...
+Strongest unasked question: ...
+Why it matters: ...
+Material questions for the user:
+- ... (or "None; proceed with the stated assumptions.")
+Reframed inquiry: ...
+Readiness: READY | NEEDS-ANSWER | BLOCKED
+```
+
+Use `NEEDS-ANSWER` only for a material user choice. Use `BLOCKED` only when required evidence or authority cannot be obtained within scope.

package/skills/necktie-critique/agents/openai.yaml

@@ -0,0 +1,6 @@
+interface:
+  display_name: "Necktie Critique"
+  short_description: "Challenge goals and surface blind spots"
+  default_prompt: "Use $necktie-critique to challenge this inquiry before execution."
+policy:
+  allow_implicit_invocation: false

package/skills/necktie-reverse/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: necktie-reverse
+description: Reverse-engineer an iterative conversation, critique, and successful refinements into one fresh-session executable brief. Use inside the Necktie loop, when the user asks for prompt reversal, when a sequence of revisions should become a reusable prompt, or when execution must be separated from prior answer leakage.
+---
+
+# Necktie Reverse
+
+Compile the useful decisions from an iterative exchange into one self-contained brief that could have produced the desired result in a fresh session.
+
+## Build the brief
+
+1. Read [references/blueprint-template.md](references/blueprint-template.md) completely.
+2. Extract the stable goal, audience, constraints, approved refinements, source hierarchy, required deliverables, acceptance criteria, and verification requirements.
+3. Preserve explicit user choices. Resolve contradictions by favoring the latest explicit instruction, then higher-authority constraints, then the option best aligned with the stated goal.
+4. Incorporate critique findings that materially improve correctness, usefulness, risk control, or verifiability.
+5. Exclude conversational debris, abandoned approaches, praise, hidden reasoning, and claims that appeared only in prior outputs.
+6. Require fresh execution from raw sources. Label prior outputs as hypotheses or style references unless independently supported.
+7. Include a reviewer contract with an exact decision vocabulary and stopping rule.
+8. Make the brief specific enough to execute yet independent of a particular model, tool name, or unavailable session state.
+
+## Quality test
+
+Before returning the brief, verify that a capable agent in a new session could answer all of these from the brief alone:
+
+- What outcome matters, for whom, and why?
+- Which sources can prove claims, and which only guide the method?
+- What is in and out of scope?
+- What must be delivered and in what form?
+- What constitutes acceptance or failure?
+- What should be checked, by whom, and when should the loop stop?
+
+If a material answer is missing, ask one focused question or state a safe assumption. Do not smuggle unresolved ambiguity into vague language.
+
+## Output
+
+Return:
+
+1. `Executable brief` in a single copyable block using the template headings.
+2. `Compilation notes` listing only material assumptions, excluded prior-output claims, and unresolved limitations.
+
+Do not include a transcript summary or chain-of-thought.