nono-skills 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 thitikorn.j
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+# Nono Skills
+
+A lightweight, reasoning-first engineering workflow pack for Codex. It provides 15 namespaced skills built around outcomes, evidence, verification, material decisions, and human escalation.
+
+The pack is designed for capable reasoning models such as GPT-5.6 Sol. Skills define intent and guardrails while leaving implementation strategy to the model. They do not impose mandatory approval gates, worktrees, test-first development, or subagent orchestration.
+
+## How it works
+
+- Codex can select a skill implicitly from its focused trigger description, or you can invoke one explicitly.
+- Each skill defines its purpose, inputs, outputs, rules, decision-log updates, and conditions that require human judgment.
+- Workflow artifacts are optional. Skills update existing artifacts but do not create missing `docs/agent/` files unless you request durable artifacts or run `init`.
+- Decision logs capture costly, contractual, ambiguous, or risk-bearing choices—not routine edits or shell commands.
+- Overlapping intents have explicit boundaries: brainstorm before direction, plan after direction, implement general changes, fix-findings for validated findings, review for general defects, and security-review when security is the primary objective.
+
+## Install
+
+Requires Node.js 20 or newer and Codex CLI with plugin support.
+
+```bash
+npx nono-skills install
+```
+
+Start a new Codex task after installation. Skills appear under the `engineering` namespace:
+
+```text
+$engineering:plan
+$engineering:implement
+$engineering:review
+$engineering:fix-findings
+$engineering:architecture-review
+$engineering:security-review
+$engineering:test
+$engineering:debug
+$engineering:refactor
+$engineering:release-readiness
+$engineering:brainstorm
+$engineering:estimate
+$engineering:migration
+$engineering:api-design
+$engineering:database-design
+```
+
+### Choosing a skill
+
+| Intent | Skill |
+|---|---|
+| Explore options before choosing a direction | `$engineering:brainstorm` |
+| Turn defined work into a verifiable execution map | `$engineering:plan` |
+| Build a general software change | `$engineering:implement` |
+| Correct validated findings | `$engineering:fix-findings` |
+| Review a change without editing it | `$engineering:review` |
+| Assess security as the primary objective | `$engineering:security-review` |
+| Evaluate system structure and change cost | `$engineering:architecture-review` |
+| Isolate a root cause from runtime evidence | `$engineering:debug` |
+| Add focused behavioral or regression tests | `$engineering:test` |
+| Improve internal structure without changing behavior | `$engineering:refactor` |
+| Assess merge, release, or deployment readiness | `$engineering:release-readiness` |
+| Estimate effort with ranges and uncertainty | `$engineering:estimate` |
+| Design a reversible transition | `$engineering:migration` |
+| Design a stable consumer contract | `$engineering:api-design` |
+| Design persistent data around invariants | `$engineering:database-design` |
+
+## Initialize a project
+
+Initialization is optional. Add concise repository guidance and shared agent artifacts to the current project with:
+
+```bash
+npx nono-skills init
+```
+
+Preview changes or target another repository:
+
+```bash
+npx nono-skills init --dry-run
+npx nono-skills init ../my-project
+```
+
+Existing differing files are reported as conflicts and no files are written. To replace them explicitly, create timestamped backups first:
+
+```bash
+npx nono-skills init --force
+```
+
+Project artifacts include a repository-focused `AGENTS.md` and `docs/agent/` templates for specs, plans, decisions, findings, and handoffs. Without initialization, skills return the same material information in their final response instead of creating workflow files.
+
+## Maintain the installation
+
+```bash
+npx nono-skills doctor
+npx nono-skills update
+npx nono-skills uninstall
+```
+
+Start a new Codex task after install or update so the refreshed skill definitions are loaded.
+
+Uninstall preserves project files. Remove only project files that still match their installed checksums with:
+
+```bash
+npx nono-skills uninstall --purge-project /path/to/project
+```
+
+Modified project files are always preserved.
+
+## Moving away from Superpowers
+
+Install this plugin, start a new task, and verify the `engineering:*` skills first. Then open `/plugins`, select Superpowers, and press Space to disable it reversibly. After normal work succeeds without it, uninstall Superpowers from the plugin browser. Do not delete Codex plugin cache directories manually.
+
+This pack intentionally does not reproduce strict test-first enforcement, automatic worktrees, mandatory design approval gates, or subagent-driven execution. Add separate focused skills for those behaviors when a task genuinely needs them.
+
+## Safety model
+
+- The installer owns only the `engineering` plugin entry and source files recorded in its checksum manifest.
+- Marketplace edits preserve unrelated entries and metadata.
+- Install and update roll back plugin source and marketplace changes when Codex registration fails.
+- Project files are never overwritten without `--force` and a backup.
+- Skills do not create missing workflow artifacts implicitly.
+- The CLI never disables or removes Superpowers automatically.
+
+## Development
+
+```bash
+npm test
+npm run validate
+npm pack --dry-run
+```
+
+The runtime has no third-party dependencies.

package/bin/cli.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { run } from '../src/cli.js';
+import { createHandlers } from '../src/commands.js';
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const packageJson = JSON.parse(await readFile(path.join(packageRoot, 'package.json'), 'utf8'));
+const context = {
+  packageRoot,
+  packageVersion: packageJson.version,
+  home: os.homedir(),
+  cwd: process.cwd(),
+  stdout: process.stdout,
+  stderr: process.stderr,
+};
+context.handlers = createHandlers(context);
+
+process.exitCode = await run(process.argv.slice(2), context);

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "nono-skills",
+  "version": "0.1.0",
+  "description": "Install a lightweight engineering workflow plugin for Codex.",
+  "author": "thitikorn.j",
+  "type": "module",
+  "bin": {
+    "nono-skills": "bin/cli.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test",
+    "validate": "node scripts/validate.mjs",
+    "prepublishOnly": "npm test && npm run validate"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "plugin/",
+    "templates/",
+    "scripts/validate.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "codex",
+    "skills",
+    "plugin",
+    "engineering",
+    "workflow"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nono911/nono-skills.git"
+  },
+  "homepage": "https://github.com/nono911/nono-skills#readme",
+  "bugs": {
+    "url": "https://github.com/nono911/nono-skills/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/plugin/.codex-plugin/plugin.json

@@ -0,0 +1,26 @@
+{
+  "name": "engineering",
+  "version": "0.1.0",
+  "description": "Lightweight, reasoning-first engineering workflows for Codex.",
+  "author": {
+    "name": "thitikorn.j"
+  },
+  "homepage": "https://github.com/nono911/nono-skills",
+  "repository": "https://github.com/nono911/nono-skills",
+  "license": "MIT",
+  "keywords": ["codex", "engineering", "skills", "workflow"],
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "Engineering",
+    "shortDescription": "Plan, build, review, debug, and release software.",
+    "longDescription": "A concise reasoning-first engineering pack centered on outcomes, evidence, verification, material decisions, and human escalation.",
+    "developerName": "thitikorn.j",
+    "category": "Developer Tools",
+    "capabilities": ["Interactive", "Write"],
+    "defaultPrompt": [
+      "Plan this engineering task.",
+      "Implement this change and verify it.",
+      "Review the current change for defects."
+    ]
+  }
+}

package/plugin/skills/api-design/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: api-design
+description: Use when creating or changing an HTTP, RPC, event, webhook, library, or internal service contract and consumers need a stable, evolvable interface.
+---
+
+# API Design
+
+## Purpose
+
+Define a consumer-centered contract with precise semantics, failure behavior, authorization, compatibility, and operability before or alongside implementation.
+
+## Inputs
+
+- Consumer use cases, domain language, invariants, and quality constraints
+- Existing APIs, conventions, clients, schemas, auth model, and versioning policy
+- Expected scale, consistency, latency, and lifecycle needs
+
+## Outputs
+
+- Contract for operations, messages, fields, errors, auth, pagination, idempotency, and compatibility as applicable
+- Examples for normal, boundary, and failure cases
+- Implementation and migration considerations without speculative internals
+
+## Rules
+
+- Model domain capabilities, not current database tables or UI screens.
+- Define presence, nullability, units, ordering, time semantics, identifiers, and error meanings explicitly.
+- Design retries, idempotency, concurrency, pagination, rate limits, and partial failure where relevant.
+- Apply least privilege and avoid leaking internal or sensitive data.
+- Prefer additive evolution; identify every known consumer before breaking changes.
+- Do not implement unless requested.
+
+## Decision-log updates
+
+Record public contract choices, compatibility policy, naming or semantic decisions likely to recur, idempotency and consistency guarantees, and rejected alternatives with consumer impact.
+Use an existing `docs/agent/decision-log.md`. If it is absent, include the decision in the final response; create workflow artifacts only when the user requests them.
+
+## Escalate to the human
+
+Escalate when consumer requirements conflict, authorization ownership is unclear, semantics imply legal or financial commitments, a breaking change lacks a migration path, or reliability and consistency tradeoffs need product or platform ownership.

package/plugin/skills/api-design/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "API Design"
+  short_description: "Design stable contracts around consumer needs"
+  default_prompt: "Use $api-design to define a stable, evolvable contract for these consumers."

package/plugin/skills/architecture-review/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: architecture-review
+description: Use when architecture is the primary review objective for boundaries, coupling, ownership, scalability, resilience, maintainability, or long-term change cost.
+---
+
+# Architecture Review
+
+## Purpose
+
+Evaluate whether system structure supports the stated product and operational needs, using repository evidence rather than generic pattern scoring.
+
+## Inputs
+
+- Goals, constraints, quality attributes, diagrams or proposals
+- Current modules, dependencies, data flows, deployment topology, and ownership boundaries
+- Known scale, failure modes, and change scenarios
+
+## Outputs
+
+- Current-state model and material architectural findings
+- Tradeoff analysis with prioritized recommendations
+- Explicit assumptions, residual risks, and staged options when change is warranted
+
+## Rules
+
+- Start from desired capabilities and likely changes, not fashionable architecture.
+- Trace dependency direction, state ownership, contracts, failure propagation, and operational boundaries.
+- Separate structural problems from local code-quality issues.
+- Quantify scale or cost claims when evidence exists; label estimates otherwise.
+- Prefer incremental, reversible improvements and describe migration cost.
+- Remain read-only unless implementation is explicitly requested.
+
+## Decision-log updates
+
+Record accepted boundaries, ownership, technology choices, quality-attribute priorities, and deliberately accepted coupling or debt. Capture alternatives and migration consequences.
+Use an existing `docs/agent/decision-log.md`. If it is absent, include the decision in the final response; create workflow artifacts only when the user requests them.
+
+## Escalate to the human
+
+Escalate when priorities conflict, ownership is unclear, a recommendation commits the team to major platform or vendor cost, or missing product and operational constraints prevent a defensible recommendation.

package/plugin/skills/architecture-review/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Architecture Review"
+  short_description: "Evaluate boundaries, coupling, ownership, and change cost"
+  default_prompt: "Use $architecture-review to assess this design against its real constraints and change scenarios."

package/plugin/skills/brainstorm/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: brainstorm
+description: Use when a product, feature, technical approach, workflow, or problem space needs distinct options explored before choosing a direction or writing an execution plan.
+---
+
+# Brainstorm
+
+## Purpose
+
+Turn an unclear opportunity into a small set of distinct, evidence-aware options and a recommended direction without prematurely implementing one.
+
+## Inputs
+
+- Desired outcome, users, constraints, known pain, and prior attempts
+- Relevant repository, product, operational, and market evidence available in scope
+- Decision deadline and reversibility
+
+## Outputs
+
+- Problem framing and success signals
+- Two to four meaningfully different options with tradeoffs
+- Recommendation, key assumptions, risks, and cheapest next experiment
+- Proposed spec updates only when the direction is accepted or explicitly requested
+
+## Rules
+
+- Clarify the outcome before generating solutions.
+- Prefer distinct strategies over cosmetic variants.
+- Separate facts, assumptions, and hypotheses.
+- Evaluate user value, complexity, risk, reversibility, and operational cost.
+- Recommend a direction when evidence supports one; do not hide behind an unranked list.
+- Do not implement during exploration unless explicitly asked.
+
+## Decision-log updates
+
+Record the selected direction, rejected alternatives when the tradeoff may recur, key assumptions to validate, and the next experiment. Keep unselected raw ideas out of the durable log unless they explain a decision.
+Use an existing `docs/agent/decision-log.md`. If it is absent, include the decision in the final response; create workflow artifacts only when the user requests them.
+
+## Escalate to the human
+
+Escalate when the core user or outcome is unknown, options encode incompatible product strategies, ethical or legal risk is material, or a choice commits significant time, spend, vendor lock-in, or irreversible data design.

package/plugin/skills/brainstorm/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Brainstorm"
+  short_description: "Explore distinct options before choosing a direction"
+  default_prompt: "Use $brainstorm to frame this problem, compare distinct options, and recommend a direction."

package/plugin/skills/database-design/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: database-design
+description: Use when designing or changing persistent data models, schemas, constraints, indexes, transactions, tenancy, retention, or query patterns.
+---
+
+# Database Design
+
+## Purpose
+
+Create a data model that enforces domain invariants, serves proven access patterns, evolves safely, and has explicit consistency and lifecycle semantics.
+
+## Inputs
+
+- Domain concepts, invariants, lifecycle, ownership, and access patterns
+- Expected cardinality, volume, growth, concurrency, latency, tenancy, and retention
+- Existing schema, queries, migrations, engine capabilities, and operational constraints
+
+## Outputs
+
+- Entities, relationships, keys, constraints, indexes, transaction boundaries, and lifecycle rules
+- Query and write-path implications with migration considerations
+- Validation approach for correctness, performance, backup, and recovery
+
+## Rules
+
+- Start with invariants and access patterns, not a table inventory.
+- Define canonical ownership and avoid duplicated mutable truth without reconciliation.
+- Use database constraints for enforceable invariants where appropriate.
+- Design indexes from real query shapes and write cost; verify with plans or representative data when possible.
+- Make tenancy, authorization boundaries, time zones, precision, deletion, audit, and retention explicit.
+- Separate schema design from authorization to run production migrations.
+
+## Decision-log updates
+
+Record data ownership, normalization tradeoffs, identifiers, consistency model, transaction boundaries, retention, tenant isolation, and irreversible schema choices. Link migration and rollback implications.
+Use an existing `docs/agent/decision-log.md`. If it is absent, include the decision in the final response; create workflow artifacts only when the user requests them.
+
+## Escalate to the human
+
+Escalate when domain truth is ambiguous, data classification or retention needs ownership, consistency and availability goals conflict, projected scale lacks evidence, or a design requires destructive migration, downtime, or irreversible data transformation.

package/plugin/skills/database-design/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Database Design"
+  short_description: "Design data around invariants and access patterns"
+  default_prompt: "Use $database-design to model this data around domain invariants and proven access patterns."

package/plugin/skills/debug/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: debug
+description: Use when behavior is wrong, failing, flaky, slow, inconsistent, or unexplained and the root cause must be isolated from runtime evidence.
+---
+
+# Debug
+
+## Purpose
+
+Reproduce the symptom, trace the failing path, falsify competing hypotheses, isolate root cause, and verify the requested resolution.
+
+## Inputs
+
+- Exact symptom, error, payload, timing, environment, and expected behavior
+- Relevant logs, traces, code paths, stored data, configuration, and recent changes
+- Reproduction access and constraints
+
+## Outputs
+
+- Minimal reproduction or strongest available evidence
+- Root cause with causal chain, not just correlation
+- If fixes are authorized: minimal fix, regression test, and verification
+- If diagnosis-only: recommended next action without source edits
+
+## Rules
+
+- Start at the observed boundary and trace backward through the real runtime and data path.
+- State hypotheses with evidence that would falsify each one; test the cheapest discriminating check first.
+- Change one variable at a time and preserve useful raw evidence.
+- Do not patch before identifying the causal mechanism unless containing an active incident is explicitly authorized.
+- Reproduce again after the fix and run adjacent regression checks.
+
+## Decision-log updates
+
+Record confirmed root cause, discarded high-likelihood hypotheses, material diagnostic pivots, chosen remediation tradeoffs, and remaining uncertainty. Avoid logging every command.
+Use an existing `docs/agent/decision-log.md`. If it is absent, include the decision in the final response; create workflow artifacts only when the user requests them.
+
+## Escalate to the human
+
+Escalate when reproduction risks data or availability, required logs or access need new authority, evidence suggests an active incident or security issue, or multiple fixes imply materially different product behavior.

package/plugin/skills/debug/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Debug"
+  short_description: "Isolate root causes from runtime evidence and verify fixes"
+  default_prompt: "Use $debug to reproduce this symptom, isolate its cause, and verify the resolution."

package/plugin/skills/estimate/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: estimate
+description: Use when software work needs an evidence-based range for effort, duration, sequencing, risk, staffing, or confidence before commitment.
+---
+
+# Estimate
+
+## Purpose
+
+Provide a transparent range derived from scope, dependencies, uncertainty, and comparable work rather than a false-precision point value.
+
+## Inputs
+
+- Goal, acceptance criteria, proposed plan, and definition of done
+- Current architecture, team and environment constraints, dependencies, and unknowns
+- Historical evidence when available
+
+## Outputs
+
+- Optimistic, likely, and pessimistic ranges with confidence
+- Work breakdown at the level needed to explain the range
+- Assumptions, exclusions, critical path, risk drivers, and uncertainty-reduction actions
+
+## Rules
+
+- Estimate the full delivery boundary requested, including verification, review, migration, rollout, and coordination when applicable.
+- Keep effort and elapsed duration separate.
+- Do not invent team velocity or historical baselines.
+- Express unknowns as ranges or scenarios, not hidden padding.
+- Re-estimate after material scope or evidence changes.
+- State the unit and whether the estimate is for one person, a team, or calendar time.
+
+## Decision-log updates
+
+Record the committed estimation basis, major assumptions, exclusions, selected scenario, and later changes that materially move the range. Do not log exploratory arithmetic.
+Use an existing `docs/agent/decision-log.md`. If it is absent, include the decision in the final response; create workflow artifacts only when the user requests them.
+
+## Escalate to the human
+
+Escalate when scope is not bounded enough to produce a useful range, staffing or dependency ownership is unknown, a deadline requires explicit scope tradeoffs, or the estimate will be treated as a commitment despite low confidence.

package/plugin/skills/estimate/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Estimate"
+  short_description: "Estimate work with ranges and explicit uncertainty"
+  default_prompt: "Use $estimate to produce an evidence-based range with assumptions, risks, and confidence."

package/plugin/skills/fix-findings/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: fix-findings
+description: Use when validated review, audit, QA, or security findings must be corrected and verified in the current codebase.
+---
+
+# Fix Findings
+
+## Purpose
+
+Resolve accepted findings at their root cause, preserve intended behavior, and produce evidence that each fix closes the reported failure.
+
+## Inputs
+
+- Findings with evidence, severity, and expected outcome
+- Current code, tests, applicable instructions, and related decisions
+- The user's authorized fix scope
+
+## Outputs
+
+- Minimal fixes and regression coverage
+- Updated finding states with verification evidence
+- Updated plan or handoff for unresolved items
+
+## Rules
+
+- Reproduce or independently validate each finding before changing code.
+- Fix the causal path, not only the visible symptom.
+- Handle findings in risk order unless dependencies require another sequence.
+- Keep unrelated refactors separate.
+- Mark `not-reproducible` or `wont-fix` only with evidence or human approval; never close by assertion.
+- Request re-review or perform an independent verification pass after fixes.
+
+## Decision-log updates
+
+Record chosen remediations when alternatives have meaningful compatibility, security, performance, or operational tradeoffs. Link the decision to finding IDs and record any accepted residual risk.
+Use existing `docs/agent/findings.md` and `decision-log.md` files when present. If they are absent, report state changes and decisions in the final response; create workflow artifacts only when the user requests them.
+
+## Escalate to the human
+
+Escalate when a finding is disputed and evidence is inconclusive, remediation changes a public contract, fixes conflict, the safe fix requires migration or downtime, or residual risk needs acceptance. Do not broaden authority from “fix” into deploy or production mutation.

package/plugin/skills/fix-findings/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Fix Findings"
+  short_description: "Resolve validated findings and prove each correction"
+  default_prompt: "Use $fix-findings to correct and verify every accepted finding in scope."

package/plugin/skills/implement/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: implement
+description: Use for general software implementation from a requirement, spec, issue, or plan; use fix-findings instead when validated findings are the primary work queue.
+---
+
+# Implement
+
+## Purpose
+
+Deliver the smallest complete change that satisfies the contract, preserves unrelated behavior, and is verified in proportion to risk.
+
+## Inputs
+
+- User request and acceptance criteria
+- Applicable repository instructions and live code paths
+- Existing spec, plan, decisions, findings, and tests
+
+## Outputs
+
+- Scoped source, test, configuration, migration, or documentation changes
+- Updated existing plan status and handoff when those artifacts are in use and work remains
+- Verification evidence and a concise change summary
+
+## Rules
+
+- Trace current behavior before editing and follow established project patterns unless evidence justifies a change.
+- Prefer the smallest coherent vertical slice over speculative infrastructure.
+- Keep compatibility unless a breaking change is explicitly authorized.
+- Add or update tests for changed behavior when a viable harness exists.
+- Do not silently weaken tests, validation, security, typing, or error handling to make checks pass.
+- Do not commit, push, deploy, or mutate external systems without explicit authorization.
+
+## Decision-log updates
+
+Record material implementation choices, deviations from the plan, assumptions that affect behavior, accepted tradeoffs, and why a simpler or established pattern was not used. Include verification or follow-up consequences.
+Use an existing `docs/agent/decision-log.md`. If it is absent, include the decision in the final response; create workflow artifacts only when the user requests them.
+
+## Escalate to the human
+
+Escalate when acceptance criteria conflict, implementation requires a breaking or destructive change, credentials or production data are required, an external action needs new authority, or the only viable approach materially expands scope. Routine code-level choices do not require escalation.

package/plugin/skills/implement/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Implement"
+  short_description: "Build the smallest complete, verified software change"
+  default_prompt: "Use $implement to deliver this software change with proportionate verification."