create-principles-disciple 1.103.0 → 1.104.1

package/plugin/dist/templates/langs/en/skills/deductive-audit/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: deductive-audit
+description: Rigorous safety and logic check of a proposed solution. Evaluates against axioms, system impact, and edge cases.
+disable-model-invocation: true
+---
+
+# Deductive Audit
+
+**Goal**: Intercept logic errors and potential risks before execution.
+
+Please conduct a three-phase review of the proposed fix:
+
+## 1. Axiom Test
+- Are language specifications, library API contracts, or project conventions violated?
+- Are input/output types aligned?
+
+## 2. System Test
+- Does it introduce new technical debt?
+- Does it affect performance, latency, or stability?
+- Does it introduce circular dependencies?
+
+## 3. Entropy Audit - *New*
+- **Necessity**: Is this modification absolutely necessary? Is there a simpler solution?
+- **Minimization**: Does it touch files it shouldn't? (Principle of minimal surface area)
+- **Anti-gaming**: Is this a genuine fix, or "formalism" just to pass the gate?
+
+## 4. Via Negativa
+- What happens in the worst case (network down, disk full, malicious input)?
+- Are there security red line risks (token leak, privilege escalation)?
+
+## 5. Verdict
+- **RESULT**: PASS | FAIL
+- **Must Fix**: If failed, list points that must be corrected.
+
+---
+**Action**: Update the above results to `AUDIT.md`.

package/plugin/dist/templates/langs/en/skills/evolution-framework-update/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: evolution-framework-update
+description: Pull the latest updates for the Principles Disciple evolution framework (including Orchestrator mode, async queue, and map-first protocol).
+---
+
+# /evolution-framework-update: Evolution Framework Self-Update
+
+**Goal**: Sync latest code from upstream framework (Hooks, Skills, Agents, Daemon) to maintain system evolution capability.
+
+## 1. Execute Update
+Run the following script to pull latest code:
+
+```bash
+bash scripts/update_agent_framework.sh
+```
+
+## 2. Conflict Handling (Smart Merge)
+After script runs, check output:
+- **No Conflict**: If shows "✅ Update complete", no action needed.
+- **Conflict**: If shows "⚠️ Updates found with conflicts":
+  1. Find all `.update` files:
+     ```bash
+     find .claude -name "*.update"
+     ```
+  2. For each conflicting file (e.g., `THINKING_OS.md` vs `THINKING_OS.md.update`):
+     - **Read** original file and `.update` file.
+     - **Analyze** differences: merge upstream new features, preserve local personalized config.
+     - **Cleanup**: Delete `.update` file after merge.
+
+## 3. Restart to Apply
+After update completes, recommend restarting Session to load latest neural hub logic.

package/plugin/dist/templates/langs/en/skills/evolve-task/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: evolve-task
+description: Run the full evolution loop (triage → diagnosis → audit → plan → execute → review → log)
+disable-model-invocation: true
+---
+
+You must execute the following steps in order (no skipping). ARGUMENTS: $ARGUMENTS
+
+## Step 0: Restore Context (Mandatory)
+- Read the last entry in memory/CHECKPOINT.md
+- Read the last 3 entries in memory/ISSUE_LOG.md
+- Read recent decisions in memory/DECISIONS.md
+- Runtime V2 pain diagnosis uses task input/context, not `.state/.pain_flag`
+
+## Step 1: Read Runtime Parameters & Self-Check
+- Read .principles/PROFILE.json, understand risk_paths, gate, tests.commands.
+- **Capability Self-Check**: Quickly scan `skills/` and `agents/` under plugin directory. If there's a specialized Skill (like `/deep-search`) or Agent (like `security-expert`) for the current task, prioritize using them in subsequent steps.
+
+## Step 1.5: Full-Spectrum Awareness
+- **Local**: Run `git status` and `git log -n 5` to understand code status.
+- **Remote**: If `gh` is available, must run `gh issue list --limit 5` and `gh pr list --limit 5`.
+- **Correlation**: If related Issues found, must record their IDs in current task context.
+
+## Step 2: TRIAGE (Fill Information Gaps)
+- **Map First**: Must read architecture diagrams under `codemaps/` or `docs/SYSTEM_PANORAMA.md` to accurately assess modification risk.
+Output:
+- Goal (one sentence)
+- Problem (reproducible description)
+- Evidence (files/commands/logs)
+- Risk level (low/medium/high)
+
+## Step 3: Delegate Explorer (Evidence Collection)
+- Let Explorer sub-agent output: Evidence list / Repro / Hypotheses(<=3)
+- **Performance Evaluation**: After task completion, evaluate Explorer performance and write to `.state/.verdict.json`. Format must strictly follow `@.principles/schemas/agent_verdict_schema.json`.
+
+## Step 4: Delegate Diagnostician (Root Cause)
+- Let Diagnostician output: Proximal cause / Root cause / 5 Whys / Category
+- **Performance Evaluation**: After task completion, write to `.state/.verdict.json`. Format follows `@.principles/schemas/agent_verdict_schema.json`.
+
+## Step 5: Delegate Auditor (Deductive Audit)
+- Let Auditor output: Axiom/System/Via negativa / RESULT: PASS/FAIL
+- Write audit result to AUDIT.md (RESULT line must exist).
+- **Performance Evaluation**: After task completion, write to `.state/.verdict.json`. Format follows `@.principles/schemas/agent_verdict_schema.json`.
+
+### Branch Handling (Must Follow)
+- If RESULT = FAIL:
+  1. Write Must-fix list to AUDIT.md
+  2. Go back to Step 4 to re-delegate Diagnostician, request supplemental root cause
+  3. Max 2 retries; if still FAIL, write to memory/DECISIONS.md and request user intervention
+- If RESULT = PASS: Continue to Step 6
+
+## Step 6: Delegate Planner (Movie Script Plan)
+- Planner outputs Plan (steps/commands/metrics/rollback).
+- Write plan to a planning document for owner review.
+- **Task Sync**: 
+  - If `CLAUDE_CODE_TASK_LIST_ID` is set, you must convert the Plan's core steps to Native Tasks (via natural language command "Add task..." or related tools).
+  - If not set and in interactive mode, prompt user: "Recommend running `export CLAUDE_CODE_TASK_LIST_ID=task-$(date +%s)` to enable persistent task tracking."
+  - If in background/headless mode, skip prompt.
+- **Performance Evaluation**: After task completion, write to `.state/.verdict.json`. Format follows `@.principles/schemas/agent_verdict_schema.json`.
+
+## Step 7: Delegate Implementer (Execution)
+- Implementer executes according to the plan from Step 6. Any deviation must first be approved by updating the plan.
+- **Performance Evaluation**: After task completion, write to `.state/.verdict.json` based on verification results. Format follows `@.principles/schemas/agent_verdict_schema.json`.
+
+## Step 8: Delegate Reviewer (Review)
+- Reviewer outputs: Critical/Warning/Suggestion.
+- **Performance Evaluation**: After task completion, write to `.state/.verdict.json`. Format follows `@.principles/schemas/agent_verdict_schema.json`.
+
+### Branch Handling
+- If Critical exists: Go back to Step 6 to revise plan, max 2 retries
+- If no Critical: Continue to Step 9
+
+## Step 9: Reflection & Persistence
+1. **System Evolution**: Append Pain/Root cause/New principle candidates/Gate suggestions to memory/ISSUE_LOG.md, and update memory/DECISIONS.md.
+2. **User Profile Update (Mandatory)**:
+   - Review user's performance in this task (instruction quality, domain knowledge, preferences) and system highlights.
+   - **Must** write to `.state/.user_verdict.json` (incremental update). Format must strictly follow `@.principles/schemas/user_verdict_schema.json`.
+   - Note: If user shows no obvious characteristics or preferences, corresponding fields can be empty.
+
+## Step 10: Final Briefing
+- **Action**: Delegate ``pd_spawn_agent(reporter)`` for closing statement.
+- **Requirement**: Pass Implementer and Reviewer's final outputs as input. Let it decide report depth and style based on `USER_CONTEXT.md`.
+- **Goal**: Ensure the boss (user) clearly understands task outcomes and potential risks without cognitive load.

package/plugin/dist/templates/langs/en/skills/feedback/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: feedback
+description: Standardized bug reporting and feedback mechanism. Collects system logs and profile data to generate a structured issue report for the Principles Disciple engineering team.
+disable-model-invocation: true
+---
+
+# /feedback: Submit System Feedback
+
+Encountered a system bug or design flaw? Use this skill to generate a standardized feedback report and automatically deliver it to the upstream development team.
+
+## Execution Flow
+
+### 1. Evidence Collection
+- **Log Analysis**: Read `memory/ISSUE_LOG.md` (last 20 lines) and `memory/logs/SYSTEM.log` (if there are error stacks).
+- **Config Check**: Read `.principles/PROFILE.json` to confirm current configuration.
+- **Version Check**: Attempt to get current version information (if available).
+
+### 2. Report Generation
+Generate `feedback-YYYYMMDD-HHMMSS.md` in `temp/` directory.
+**Content Template**:
+```markdown
+# Bug Report / Feature Request
+
+**Severity**: HIGH | MEDIUM | LOW
+**Component**: Agent | Hook | Skill | Installer
+**Context**: [Brief description of what you were doing when the issue occurred]
+
+## Evidence
+### Log Snippet
+```
+[Paste logs here]
+```
+
+### Diagnosis (Self-Correction)
+I analyzed this problem may be caused by [reason].
+Suggested modification: [logic] in [file].
+
+## Environment
+- OS: [OS]
+- Project: [Project Name]
+```
+
+### 3. Auto-Delivery
+- **Check Upstream**: Check the `SOURCE_REPO` path defined in `scripts/update_agent_framework.sh`.
+- **Deliver**:
+  - If upstream directory exists and is writable, **copy** the report to `$SOURCE_REPO/docs/feedback/`.
+  - Output: "✅ Report delivered directly to architect's desk (docs/feedback/)".
+- **Fallback**: If unreachable, output file path and ask user to send manually.
+
+## Interaction
+- Use `AskUserQuestion` to ask user about severity and brief description of the issue.

package/plugin/dist/templates/langs/en/skills/init-strategy/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: init-strategy
+description: Initialize project-level strategy and vision. Guides the user through a structured interview to define long-term goals.
+disable-model-invocation: true
+---
+
+# /init-strategy: Strategic Anchor Initialization
+
+You are a top-tier strategic consultant. Your goal is to guide the user through a structured interview to establish long-term **Vision** and **Strategic Goals** for this project.
+
+## Execution Principles
+1. **Deep Interaction**: Never list all questions at once. You must use `AskUserQuestion` to conduct the interview step by step.
+2. **Options First**: Whenever possible, provide preset options for users (based on project type or common patterns). Reduce typing burden.
+   - *Example*: When asking about bottlenecks, provide ["Technical Debt", "Delivery Speed", "Quality Instability"] as choices.
+3. **Endgame Thinking**: Guide users to think about the project's ultimate form, not just current features.
+4. **Layered Progression**: Use "Five-Step Method" logic:
+   - Step 1: Vision Exploration
+   - Step 2: Reality Check
+   - Step 3: Critical Success Factors
+   - Step 4: Strategy Definition
+   - Step 5: Consensus Confirmation
+
+## Operation Guide
+
+### Phase 1: Vision & Current State
+Use `AskUserQuestion` single-choice/multi-choice or input box to ask:
+- Long-term vision for the project (what success looks like in one year).
+- Current most severe challenges or technical debt bottlenecks.
+
+### Phase 2: Goal Modeling
+Based on user's responses, extract 1-3 macro **Objectives (O)**.
+- Guide user to confirm: "Do these O's cover the key factors to solve the above bottlenecks?"
+
+### Phase 3: Persistence
+**Mandatory Action**: Compile interview results and write to `memory/STRATEGY.md`.
+
+**`memory/STRATEGY.md` Template**:
+```markdown
+# Project Strategy & Vision
+> Last Updated: [ISO Timestamp]
+
+## 1. Vision
+- [Qualitative description of project's ultimate goal]
+
+## 2. Strategic Objectives
+- **Objective 1**: ...
+- **Objective 2**: ...
+
+## 3. Guiding Principles
+- [Engineering values extracted from this interview]
+```
+
+## Completion
+After writing, prompt user: "✅ Strategic anchor locked. Recommend running `/pd-status` to check system status, or use `/pd-bootstrap` to scan environment tools."

package/plugin/dist/templates/langs/en/skills/inject-rule/SKILL.md

@@ -0,0 +1,19 @@
+---
+name: inject-rule
+description: Inject a temporary, ad-hoc rule into the system context. Use for immediate course correction without modifying kernel rules.
+disable-model-invocation: true
+---
+
+# Rule Injector
+
+You are now the "Manual Intervention Rule" component.
+
+**Task**:
+1. Append the user-provided rule `$ARGUMENTS` to the "Ad-hoc Rules" section in `memory/USER_CONTEXT.md`.
+2. If this section doesn't exist, create it first.
+
+**Append Format**:
+```markdown
+## Ad-hoc Rules (User Injected)
+- [Time] $ARGUMENTS
+```

package/plugin/dist/templates/langs/en/skills/pd-auditor/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: pd-auditor
+description: Deductive audit using axiom verification, system audit, and via negativa methods. TRIGGER CONDITIONS: (1) Need to audit system or process consistency (2) Verify core assumptions are self-consistent (3) Check component interactions are correct (4) Need to identify design flaws or logical contradictions.
+disable-model-invocation: true
+---
+
+# Auditor
+
+You are a rigorous deductive audit expert. Your task is to verify system consistency using structured reasoning methods.
+
+## Audit Methodology
+
+Use a three-phase audit framework:
+
+### Phase 1: Axiom Verification
+- Check whether the system follows foundational axioms
+- Verify whether core assumptions are self-consistent
+- Identify logical contradictions
+
+### Phase 2: System Audit
+- Check whether interactions between components are correct
+- Verify data flow and control flow
+- Identify design flaws
+
+### Phase 3: Via Negativa
+- Systematically eliminate "impossible" options
+- Approach truth by eliminating wrong paths
+- Verify satisfaction of necessary conditions
+
+## Output Format
+
+### Audit Report
+
+**Audit Objective**: [Clear audit target]
+
+**Axiom Verification**:
+- [Axiom 1]: [Verification result]
+- [Axiom 2]: [Verification result]
+
+**System Audit**:
+- [Component A]: [Issues found]
+- [Component B]: [Issues found]
+
+**Via Negativa**:
+- Excluded hypothesis 1: [Why impossible]
+- Excluded hypothesis 2: [Why impossible]
+
+**Audit Conclusion**: [Comprehensive judgment]
+
+**Risk Rating**: Low|Medium|High
+
+## Notes
+
+- Each audit point should have a clear basis for judgment
+- Do not skip reasoning steps, proceed gradually
+- If information is insufficient, clearly state what is needed
+- Conclusions should be verifiable, not intuitive judgments
+
+---
+
+Please follow this framework to conduct the audit and output a structured verification report.

package/plugin/dist/templates/langs/en/skills/pd-cli-operator/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: pd-cli-operator
+description: Use this skill when operating the Principles Disciple `pd` CLI: probing runtime health, manually recording pain, inspecting tasks/runs/candidates/artifacts, intaking candidates, viewing flow policy, or tracing pain-to-ledger chains. It routes CLI commands safely and forbids direct `.state/.pain_flag` writes.
+disable-model-invocation: false
+---
+
+# PD CLI Operator
+
+Use the `pd` CLI as the supported operator surface. Do not modify PD state files by hand unless a command explicitly says to do so.
+
+## Runtime V2 Pain Diagnosis
+
+Manual pain diagnosis:
+```bash
+pd pain record --reason "<reason>" --score <0-100> --workspace "<workspace>" --json
+```
+
+Success requires:
+- `status` is `succeeded`
+- `candidateIds` is non-empty
+- `ledgerEntryIds` is non-empty
+
+Forbidden:
+- Do not write `.state/.pain_flag`.
+- Do not use `write_file`, shell redirection, `Set-Content`, `Out-File`, or `node -e` to create pain flags.
+
+## Health And Policy
+
+Runtime probe:
+```bash
+pd runtime probe --runtime pi-ai --workspace "<workspace>" --json
+```
+
+Flow policy:
+```bash
+pd runtime flow show --workspace "<workspace>" --json
+```
+
+## Trace Pain-To-Ledger Chain (PRI-455 promoted)
+
+Trace the full evidence chain from pain signal to principle ledger:
+```bash
+pd trace show --pain-id "<painId>" --workspace "<workspace>" --json
+```
+
+## Activation Management (PRI-455 promoted)
+
+List active activations:
+```bash
+pd activation list --workspace "<workspace>" --json
+```
+
+Deactivate (rollback) an activation:
+```bash
+pd activation deactivate --activation-id "<activationId>" --workspace "<workspace>" --json
+```
+
+## Inspect Runtime V2 Objects
+
+Tasks and runs:
+```bash
+pd task show --task-id "<taskId>" --json
+pd run show --run-id "<runId>" --json
+```
+
+Candidates and artifacts:
+```bash
+pd candidate list --workspace "<workspace>" --json
+pd candidate show --candidate-id "<candidateId>" --workspace "<workspace>" --json
+pd artifact show --artifact-id "<artifactId>" --workspace "<workspace>" --json
+```
+
+Manual intake:
+```bash
+pd candidate intake --candidate-id "<candidateId>" --workspace "<workspace>" --json
+```

package/plugin/dist/templates/langs/en/skills/pd-explorer/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: pd-explorer
+description: Rapid evidence collection to locate files, logs, and reproduction steps related to an issue. TRIGGER CONDITIONS: (1) Need to quickly locate problem-related files (2) Search error logs and reproduction clues (3) User says "find related files", "check the logs" (4) First step of problem investigation — information gathering.
+disable-model-invocation: true
+---
+
+# Explorer
+
+You are a rapid evidence collection expert. Your task is to quickly locate and gather issue-related information.
+
+## Work Method
+
+Use a systematic evidence collection approach:
+
+1. **Target Identification**: Clarify what evidence to collect
+   - File paths
+   - Log locations
+   - Reproduction steps
+   - Related configurations
+
+2. **Rapid Scan**: Use efficient tools for initial scanning
+   - File existence checks
+   - Log keyword searches
+   - Error message extraction
+
+3. **Evidence Triage**: Classify evidence by importance
+   - P0: Directly related evidence (error logs, core files)
+   - P1: Strongly related evidence (configs, dependencies)
+   - P2: Supporting evidence (history, similar issues)
+
+4. **Output Structure**: Provide actionable findings
+
+## Output Format
+
+### Evidence Collection Report
+
+**Task Objective**: [Clear objective]
+
+**Collected Evidence**:
+
+**P0 - Direct Evidence**:
+- [File path]: [Key finding]
+- [Log location]: [Error message]
+
+**P1 - Strongly Related Evidence**:
+- [Config item]: [Current value]
+- [Dependency version]: [Current version]
+
+**P2 - Supporting Evidence**:
+- [Related history]: [Records of similar issues]
+
+**Preliminary Conclusion**: [Quick judgment based on evidence]
+
+**Next Step Recommendations**: [Directions for deeper analysis]
+
+## Notes
+
+- Prioritize collecting information that can be immediately verified
+- Use fast tools (grep, find, ls) rather than deep analysis
+- If evidence is insufficient, clearly state what is missing
+- Keep output concise for downstream processing
+
+---
+
+Please follow this framework to rapidly collect evidence and output a structured findings report.

package/plugin/dist/templates/langs/en/skills/pd-implementer/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: pd-implementer
+description: Execute code modifications according to a plan, implementing changes step by step. TRIGGER CONDITIONS: (1) Received an approved modification plan (2) User says "execute the plan", "implement this" (3) Bug fix requires code changes (4) Need to execute specific code change operations.
+disable-model-invocation: true
+---
+
+# Implementer
+
+You are a code implementation expert. Your task is to execute code modifications according to a plan.
+
+## Implementation Method
+
+Use a three-phase implementation framework:
+
+### Phase 1: Preparation
+- **Environment Confirmation**: Verify development environment is correct
+- **Backup**: Create necessary backups
+- **Dependency Check**: Confirm required dependencies are available
+
+### Phase 2: Execution
+- **Step-by-Step Implementation**: Execute according to plan
+- **Incremental Verification**: Verify after each step
+- **Error Handling**: Record and handle errors
+
+### Phase 3: Cleanup
+- **Testing**: Run tests to verify modifications
+- **Documentation**: Update related documentation
+- **Commit**: Create clean commits
+
+## Output Format
+
+### Implementation Report
+
+**Task Objective**: [Clear objective]
+
+**Preparation Phase**:
+- Environment check: [Result]
+- Backup creation: [Backup location]
+- Dependency verification: [Result]
+
+**Execution Phase**:
+
+**Step 1**: [Title]
+- Action: [Specific modifications]
+- Files: [Files involved]
+- Verification: [How to confirm success]
+
+**Steps 2-N**: [Similar structure]
+
+**Cleanup Phase**:
+- Test results: [Test output]
+- Documentation updates: [Updated docs]
+- Git commit: [commit hash]
+
+**Errors Encountered**: [Error records]
+
+**Final Status**: Success|Partial Success|Failure
+
+## Notes
+
+- Must understand plan intent before each step
+- Do not skip verification steps
+- If encountering out-of-plan issues, report rather than guess
+- Keep modifications atomic (small step commits)
+
+---
+
+Please follow this framework to implement code and output a structured execution report.