@ryuenn3123/agentic-senior-core 6.16.5 → 6.17.0

package/.agents/plugins/agentic-senior-core/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-senior-core",
-  "version": "6.16.5",
+  "version": "6.17.0",
   "description": "Universal AI coding rules. Write code like a staff engineer.",
   "skills": "./skills/",
   "hooks": "./hooks/hooks.json",

package/.agents/plugins/agentic-senior-core/commands/asc-develop.md

@@ -1 +1 @@
-Run the engineering lifecycle workflow from skills/asc-develop/SKILL.md (Greenfield scaffolding, Brownfield features, and Refactoring). Research analogous modules, plan architecture and fallbacks, apply the decision ladder, and verify with tests without creating disk checkpoint files.
+Run the engineering lifecycle workflow from skills/asc-develop/SKILL.md (Greenfield scaffolding, Brownfield features, Bite-Sized Execution Plans, Subagent Orchestration, and Refactoring). Load references/execution-plans.md for planning and autonomous rulings or references/subagent-orchestration.md for parallel task dispatch, apply the decision ladder, and verify with fresh tests without creating disk checkpoint files.

package/.agents/plugins/agentic-senior-core/commands/asc-develop.toml

@@ -1,3 +1,2 @@
-description = "Engineering lifecycle for greenfield apps, brownfield features, and refactoring"
-prompt = "Load and follow the asc-develop skill. Research analogous modules, plan architecture and failure fallbacks, apply the decision ladder, and verify with tests without creating disk checkpoint files."
-
+description = "Engineering lifecycle, execution plans, subagent orchestration, and refactoring"
+prompt = "Load and follow the asc-develop skill (including references/execution-plans.md for bite-sized plans and rulings, or references/subagent-orchestration.md for parallel subagent dispatch). Research analogous modules, apply the decision ladder, and verify with fresh tests without creating disk checkpoint files."

package/.agents/plugins/agentic-senior-core/commands/asc-test.md

@@ -1,2 +1 @@
-Run the testing, TDD, verification, and UAT standards from skills/asc-test/SKILL.md. Enforce the Iron Law (no production code without a failing test first), apply verification gates with fresh execution evidence, reproduce bugfixes with regression proofs, design boundary-isolated tests, and diagnose flaky tests.
-
+Run the testing, systematic root-cause debugging, TDD, verification, and UAT standards from skills/asc-test/SKILL.md. Load references/systematic-debugging.md to investigate root causes before editing production code, enforce test-first discipline, apply verification gates with fresh execution evidence, reproduce bugfixes with regression proofs, and remediate flaky tests.

package/.agents/plugins/agentic-senior-core/commands/asc-test.toml

@@ -1,3 +1,2 @@
-description = "Test-driven development, verification gates, Playwright E2E, and UAT"
-prompt = "Load and follow the asc-test skill. Enforce the Iron Law of TDD (no production code without a failing test first), apply verification gates with fresh execution evidence, perform regression proofs on bugfixes, design boundary-isolated tests without mocking the unit under test, and trace flaky tests."
-
+description = "Systematic root-cause debugging, TDD, verification gates, Playwright E2E, and UAT"
+prompt = "Load and follow the asc-test skill (including references/systematic-debugging.md for root-cause investigation before code edits). Enforce test-first discipline, apply verification gates with fresh execution evidence, perform regression proofs on bugfixes, design boundary-isolated tests, and remediate flaky tests."

package/.agents/plugins/agentic-senior-core/commands/asc-ui.md

@@ -1 +1 @@
-Run the UI/UX engineering and anti-slop guidelines from skills/asc-ui/SKILL.md. Clean up verbose microcopy, eliminate redundant headings/subtitles, enforce single-language purity without awkward foreign loanwords, optimize information density, and implement reliable data states.
+Run the deterministic frontend engineering standards from skills/asc-ui/SKILL.md. Reuse existing workspace tokens and components/ui primitives, enforce anti-card-soup structural mapping (references/data-to-structure.md: <ol> steppers, <table> matrices, divide-y rosters, flat <dl> stats), verify the 4-state data contract and WCAG 2.2 AA accessibility (references/states-and-a11y.md), and enforce 100dvh mobile containment and single-language microcopy (references/responsive-and-copy.md).

package/.agents/plugins/agentic-senior-core/commands/asc-ui.toml

@@ -1,3 +1,2 @@
-description = "UI/UX engineering, microcopy hygiene, and anti-slop design"
-prompt = "Load and follow the asc-ui skill. Inspect the target UI components and layouts. Strip out AI slop: eliminate redundant subtitles repeating headers, cut verbose copy by 50%, remove marketing buzzwords in functional tools, enforce strict single-language consistency without unidiomatic foreign loanwords, replace generic 3-card templates with scannable information density, and ensure proper state quad (loading, empty, error, populated) handling."
-
+description = "Deterministic frontend engineering, anti-card-soup structure, states, and WCAG accessibility"
+prompt = "Load and follow the asc-ui skill. Reuse existing workspace CSS tokens and components/ui primitives, enforce deterministic data-to-structure mapping (references/data-to-structure.md) instead of repeated card grids, implement all 4 data states and WCAG 2.2 AA accessibility (references/states-and-a11y.md), and enforce min-h-dvh mobile containment and single-language microcopy (references/responsive-and-copy.md)."

package/.agents/plugins/agentic-senior-core/hooks/lib/known-ui-slop-patterns.json

@@ -159,6 +159,16 @@
       "id": "copy-filler-preamble",
       "regex": "\\b(In today's (?:fast-paced|digital)|Built for (?:the )?modern teams?|Welcome to the)\\b",
       "message": "note: AI preamble/filler detected ('In today\\'s fast-paced...', 'Built for modern teams'). Delete the introductory throat-clearing and lead with action."
+    },
+    {
+      "id": "copy-clumsy-indonesian-translations",
+      "regex": "\\b(laci sembul|jendela sembul|garis rambut|panggung asimetris)\\b",
+      "message": "warning: clumsy literal translation detected ('laci sembul', 'garis rambut'). Use natural Indonesian ('panel samping', 'garis tipis', 'area utama')."
+    },
+    {
+      "id": "ui-numbered-step-card",
+      "regex": "rounded-(?:xl|2xl)[^>{}]{0,120}\\bborder\\b[\\s\\S]{0,160}>\\s*0[1-9]\\s*</",
+      "message": "warning: numbered step card ('01', '02' inside bordered rounded card) detected. Render sequential workflows as a connected <ol> stepper instead of isolated cards."
     }
   ]
 }

package/.agents/plugins/agentic-senior-core/hooks/post-edit-enforce.js

@@ -176,22 +176,69 @@ function handleAntigravityPostInvocation(data) {
     const findings = [];
     const minStep = typeof data.initialNumSteps === 'number' ? data.initialNumSteps : 0;
 
-    let sourceEditsSinceStart = 0;
+    const parsedSteps = [];
+    let lastUserInputIdx = 0;
     for (let i = 0; i < lines.length; i++) {
-      let step;
       try {
-        step = JSON.parse(lines[i]);
-      } catch (_) {
-        continue;
+        const s = JSON.parse(lines[i]);
+        parsedSteps.push(s);
+        if (s && s.type === 'USER_INPUT') {
+          lastUserInputIdx = parsedSteps.length - 1;
+        }
+      } catch (_) {}
+    }
+
+    const isBugPrompt = /\b(bug|error|crash|fail(?:ing|ed|s)?|broken|500|exception|kenapa gagal|kok error|benerin)\b/i
+      .test(String(data.lastUserInput || ''));
+    const testPathRe = /(?:\.test\.|\.spec\.|_test\.|__tests__[\/\\]|tests?[\/\\])/i;
+
+    let priorTurnReproOrTest = false;
+    for (let i = lastUserInputIdx; i < parsedSteps.length; i++) {
+      const s = parsedSteps[i];
+      if (!s || s.step_index >= minStep || s.type !== 'PLANNER_RESPONSE' || !Array.isArray(s.tool_calls)) continue;
+      for (let j = 0; j < s.tool_calls.length; j++) {
+        const tc = s.tool_calls[j];
+        if (!tc) continue;
+        if (tc.name === 'run_command' || tc.name === 'Bash' || tc.name === 'run_shell_command') {
+          priorTurnReproOrTest = true;
+        }
+        const n = normalizeEditToolCall(tc.name, tc.args);
+        if (n && n.filePath && testPathRe.test(n.filePath)) {
+          priorTurnReproOrTest = true;
+        }
       }
-      if (step.step_index >= minStep && step.type === 'PLANNER_RESPONSE' && Array.isArray(step.tool_calls)) {
+    }
+
+    let sourceEditsSinceStart = 0;
+    let prodEditsThisInv = 0;
+    let reproOrTestThisInv = false;
+
+    for (let i = 0; i < parsedSteps.length; i++) {
+      const step = parsedSteps[i];
+      if (step && step.step_index >= minStep && step.type === 'PLANNER_RESPONSE' && Array.isArray(step.tool_calls)) {
         for (let j = 0; j < step.tool_calls.length; j++) {
           const tc = step.tool_calls[j];
-          const norm = tc ? normalizeEditToolCall(tc.name, tc.args) : null;
+          if (!tc) continue;
+          if (tc.name === 'run_command' || tc.name === 'Bash' || tc.name === 'run_shell_command') {
+            reproOrTestThisInv = true;
+            continue;
+          }
+          if (tc.args && (tc.args.ArtifactMetadata || tc.args.IsArtifact)) continue;
+
+          const norm = normalizeEditToolCall(tc.name, tc.args);
           if (!norm || !norm.filePath) continue;
 
+          if (testPathRe.test(norm.filePath)) {
+            reproOrTestThisInv = true;
+          }
+
           const ext = path.extname(norm.filePath).slice(1);
-          if (SOURCE_EXTENSIONS.has(ext)) sourceEditsSinceStart++;
+          if (SOURCE_EXTENSIONS.has(ext)) {
+            sourceEditsSinceStart++;
+            if (!testPathRe.test(norm.filePath)) {
+              prodEditsThisInv++;
+            }
+          }
 
           const mappedInput = norm.canonicalTool === 'Edit'
             ? { file_path: norm.filePath, new_string: norm.newContent, old_string: norm.oldContent }
@@ -204,6 +251,10 @@ function handleAntigravityPostInvocation(data) {
       }
     }
 
+    if (isBugPrompt && prodEditsThisInv > 0 && !priorTurnReproOrTest && !reproOrTestThisInv) {
+      findings.push('[ASC Systematic Debugging] Production code was edited for a bug/error report before running a reproduction command or writing a failing regression test. Follow skills/asc-test/references/systematic-debugging.md (investigate root cause and reproduce first).');
+    }
+
     if (sourceEditsSinceStart >= SESSION_DRIFT_THRESHOLD) {
       findings.push('[ASC Session Drift] ' + sourceEditsSinceStart + ' source file edits this invocation. '
         + 'Re-read the decision ladder before continuing: (1) Does this need to be built? '
@@ -263,7 +314,7 @@ function processSingleEdit(toolName, toolInput, emitFn, workspaceRoot, skipSessi
   checkSecurityPatterns(toolName, toolInput, filePath, findings);
   checkStubPatterns(toolName, toolInput, filePath, findings);
 
-  if (ext === 'html' || ext === 'css' || ext === 'jsx' || ext === 'tsx' || ext === 'vue' || ext === 'svelte') {
+  if (ext === 'html' || ext === 'css' || ext === 'jsx' || ext === 'tsx' || ext === 'vue' || ext === 'svelte' || filePath.toLowerCase().endsWith('.blade.php')) {
     checkUiSlopPatterns(toolName, toolInput, filePath, findings);
   }
 
@@ -429,6 +480,16 @@ function checkUiSlopPatterns(toolName, toolInput, filePath, findings) {
       } catch (_) { }
     });
   }
+
+  var cardGridRe = /<(?:section|div)[^>]*\bgrid\b[\s\S]{0,260}?rounded-(?:xl|2xl)[^>]*\bborder\b/ig;
+  var cardGrids = target.match(cardGridRe) || [];
+  var hasSemanticTableOrList = /<(?:table|ol)[\s>]/i.test(target);
+  if (cardGrids.length >= 3 && !hasSemanticTableOrList) {
+    findings.push(
+      '[ASC Card Soup Alert] ' + cardGrids.length + ' bordered card-grid sections detected in ' + path.basename(filePath)
+      + ' with zero semantic <table> or <ol> containers. Convert sequential steps to <ol> steppers, criteria/records to <table>, and rosters to divide-y lists (skills/asc-ui/references/data-to-structure.md).'
+    );
+  }
 }
 
 function checkStubPatterns(toolName, toolInput, filePath, findings) {

package/.agents/plugins/agentic-senior-core/hooks/stop-verify-gate.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+// Antigravity Stop hook — enforces fresh verification command execution
+// after source-code modifications before allowing turn completion.
+
+const fs = require('fs');
+const path = require('path');
+const { SOURCE_EXTENSIONS } = require('./constants.cjs');
+const { normalizeEditToolCall } = require('./path-util.cjs');
+
+function allowStop() {
+  process.stdout.write(JSON.stringify({ decision: 'allow' }) + '\n');
+  process.exit(0);
+}
+
+if (process.stdin.isTTY) {
+  allowStop();
+}
+
+let handled = false;
+let inputBuffer = '';
+
+function evaluateStop(data) {
+  if (handled) return;
+  handled = true;
+  clearTimeout(timer);
+
+  try {
+    if (!data || typeof data !== 'object') {
+      allowStop();
+      return;
+    }
+
+    // Never block when background tasks/subagents are still active
+    if (data.fullyIdle !== true) {
+      allowStop();
+      return;
+    }
+
+    // Only gate normal model completion, never system errors or step limits
+    if (data.terminationReason && data.terminationReason !== 'model_stop') {
+      allowStop();
+      return;
+    }
+
+    // Single-retry cap prevents infinite continuation loops
+    if (typeof data.executionNum === 'number' && data.executionNum >= 2) {
+      allowStop();
+      return;
+    }
+
+    if (!data.transcriptPath || !fs.existsSync(data.transcriptPath)) {
+      allowStop();
+      return;
+    }
+
+    const lines = fs.readFileSync(data.transcriptPath, 'utf8').split('\n').filter(Boolean);
+    const steps = [];
+    for (let i = 0; i < lines.length; i++) {
+      try {
+        steps.push(JSON.parse(lines[i]));
+      } catch (_) {}
+    }
+
+    let startIdx = 0;
+    for (let i = steps.length - 1; i >= 0; i--) {
+      if (steps[i] && steps[i].type === 'USER_INPUT') {
+        startIdx = i + 1;
+        break;
+      }
+    }
+
+    const artifactDir = typeof data.artifactDirectoryPath === 'string' && data.artifactDirectoryPath
+      ? path.resolve(data.artifactDirectoryPath).toLowerCase()
+      : '';
+
+    let lastSourceEditIdx = -1;
+    let lastVerifyCmdIdx = -1;
+
+    for (let i = startIdx; i < steps.length; i++) {
+      const step = steps[i];
+      if (!step || step.type !== 'PLANNER_RESPONSE' || !Array.isArray(step.tool_calls)) continue;
+
+      for (let j = 0; j < step.tool_calls.length; j++) {
+        const tc = step.tool_calls[j];
+        if (!tc || !tc.name) continue;
+
+        if (tc.name === 'run_command' || tc.name === 'Bash' || tc.name === 'run_shell_command') {
+          lastVerifyCmdIdx = i;
+          continue;
+        }
+
+        const args = tc.args || {};
+        if (args.ArtifactMetadata || args.IsArtifact) continue;
+
+        const norm = normalizeEditToolCall(tc.name, args);
+        if (!norm || !norm.filePath) continue;
+
+        if (artifactDir) {
+          const resolvedEdit = path.resolve(norm.filePath).toLowerCase();
+          if (resolvedEdit.startsWith(artifactDir)) continue;
+        }
+
+        const ext = path.extname(norm.filePath).slice(1).toLowerCase();
+        if (SOURCE_EXTENSIONS.has(ext)) {
+          lastSourceEditIdx = i;
+        }
+      }
+    }
+
+    if (lastSourceEditIdx !== -1 && lastVerifyCmdIdx < lastSourceEditIdx) {
+      process.stdout.write(JSON.stringify({
+        decision: 'continue',
+        reason: '[ASC Verification Gate] Source code was modified this turn without running a fresh verification or test command afterward. Execute the relevant test, build, or syntax check command and confirm exit code 0 before concluding.',
+      }) + '\n');
+      process.exit(0);
+      return;
+    }
+
+    allowStop();
+  } catch (_) {
+    allowStop();
+  }
+}
+
+const timer = setTimeout(function () { evaluateStop(null); }, 2500);
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', function (chunk) {
+  inputBuffer += chunk;
+  try {
+    const parsed = JSON.parse(inputBuffer);
+    evaluateStop(parsed);
+  } catch (_) {}
+});
+
+process.stdin.on('end', function () {
+  if (handled) return;
+  if (!inputBuffer.trim()) {
+    evaluateStop(null);
+    return;
+  }
+  try {
+    evaluateStop(JSON.parse(inputBuffer));
+  } catch (_) {
+    evaluateStop(null);
+  }
+});
+

package/.agents/plugins/agentic-senior-core/hooks.json

@@ -25,6 +25,13 @@
         "command": "node hooks/post-edit-enforce.js",
         "timeout": 15
       }
+    ],
+    "Stop": [
+      {
+        "type": "command",
+        "command": "node hooks/stop-verify-gate.js",
+        "timeout": 5
+      }
     ]
   }
 }

package/.agents/plugins/agentic-senior-core/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agentic-senior-core",
   "displayName": "Agentic Senior Core",
-  "version": "6.16.5",
+  "version": "6.17.0",
   "description": "Universal AI coding rules and workflows. Write code like a staff engineer.",
   "author": "fatidaprilian",
   "repository": "https://github.com/fatidaprilian/Agentic-Senior-Core"

package/.agents/plugins/agentic-senior-core/rules/agentic-senior-core.md

@@ -46,7 +46,8 @@ When picking step 5 or 6 (unless trivial):
   - 50% reduction rule: Write the statement, then cut unnecessary words. Replace ornamental adjectives with measurable facts (not "a robust, blazing-fast parser", write "parses 50MB/s with zero heap allocations").
   - Ban AI cadences: Never use the Tricolon ("Fast. Simple. Secure."), the Mad-Lib ("The AI-powered platform for modern teams"), the Rebuttal ("Not just a tool, it's a workflow"), or conversational throat-clearing ("In today's fast-paced landscape...").
   - Buzzword blacklist: Never emit `seamless(ly)`, `robust`, `empower(ing)`, `supercharge`, `elevate`, `effortless(ly)`, `cutting-edge`, `delve`, `testament`, `pivotal`, `crucial`, `game-changing`, or `next-generation`.
-  - Strict single-language purity: Choose one language per document or surface. In Indonesian contexts, never prefix grammatical affixes to raw English stems (`di-submit`, `meng-generate`, `di-approve`, `me-restore`).
+  - Strict single-language purity: Choose one language per document or surface. Never mix languages within a single deliverable. Never append parenthetical translation glosses to technical concepts. In localized contexts, translate concepts into the target language's natural, idiomatic engineering terms rather than clumsy literal calques.
+  - Silent internal framework discipline: Never leak ASC internal rule names, checklists, or meta-labels into user-facing plans, UI copy, or code comments. Focus purely on technical and domain facts.
 - Code comment hygiene: Zero decorative character banners (// =====), zero line-by-line narration (// Step 1: validate), zero empty category tags (// Main logic), and zero signature echoes in docstrings. Keep only comments that document non-obvious operational constraints, security boundaries, concurrency hazards, or protocol contracts.
 - Delete code that carries no behavior, safety, or test value. Readability wins over brevity.
 - Detect and respect project linter/formatter configs. Do not restate style rules enforced by tooling.

package/.agents/plugins/agentic-senior-core/skills/asc/SKILL.md

@@ -10,16 +10,17 @@ Universal AI coding rules and meta-tooling playbook. Grounded in Google Engineer
 
 ---
 
-## 1. The 6 Core Meta-Skills Architecture
+## 1. The 7 Core Meta-Skills Architecture
 
-Agentic Senior Core organizes operational guidance into 6 high-density, non-overlapping playbooks:
+Agentic Senior Core organizes operational guidance into 7 high-density, non-overlapping playbooks:
 
-1. **`/asc` (This Skill)**: Core engineering rules, codebase convention fingerprinting, adaptive preferences, debt tracking, skill authoring, and IDE adapter setup.
-2. **`/asc-develop`**: Engineering lifecycle for greenfield scaffolding, brownfield feature implementation, and structured refactoring.
+1. **`/asc` (This Skill)**: Core engineering rules, codebase convention fingerprinting, adaptive preferences, debt tracking, skill authoring & subagent pressure testing, and IDE adapter setup.
+2. **`/asc-develop`**: Engineering lifecycle for greenfield scaffolding, brownfield features, bite-sized execution plans (`Ruling:` execution), subagent orchestration, and structured refactoring.
 3. **`/asc-review`**: Quality and security assurance: production PR reviews, deep vulnerability audits (OWASP / ASI), and code clone deduplication.
-4. **`/asc-test`**: Dedicated testing playbook: the Iron Law of TDD, verification gates, Playwright E2E, UAT acceptance checklists, regression proofs, and flaky test remediation.
+4. **`/asc-test`**: Dedicated testing & debugging playbook: 4-phase systematic root-cause debugging, TDD, verification gates, Playwright E2E, UAT checklists, regression proofs, and flaky test remediation.
 5. **`/asc-reference`**: Domain architecture reference for REST/GraphQL APIs, database indexing/transactions/migrations, infrastructure configs, and service resilience.
-6. **`/asc-ui`**: Human-interface engineering: surface modes (Operate, Persuade, Read, Experience), UX microcopy hygiene, single-language localization, mobile reflow (`dvh`/`clamp`), and WCAG 2.2 AA accessibility.
+6. **`/asc-ui`**: Deterministic frontend engineering: anti-card-soup data-to-structure mapping, token/primitive reuse, 4-state data contracts, mobile containment (`min-h-dvh`), single-language microcopy, and WCAG 2.2 AA accessibility.
+7. **`/asc-pentest`**: Authorized dynamic security verification: scope gates, Pentest Task Trees, multi-principal BOLA/IDOR matrices, and OWASP API Top 10 stateful fuzzing.
 
 ---
 

package/.agents/plugins/agentic-senior-core/skills/asc/references/writing-skills.md

@@ -4,7 +4,7 @@ Engineering guidelines for creating high-performance, token-efficient skills for
 
 ---
 
-## 1. The Discovery & Routing Trap
+## 1. Skill Discovery & Trigger Precision
 
 Research into agent skill selection shows that models degrade in tool and skill routing when descriptions summarize internal workflows.
 
@@ -70,3 +70,18 @@ A skill without a verifiable gate is merely a suggestion.
 - Every modification must be coupled with an automated verification command (linter, unit test, Playwright run, or slop pattern check).
 - Mandate fresh execution evidence: require the agent to execute the runner fresh and verify exit code 0 before claiming completion.
 
+---
+
+## 5. Subagent Pressure Testing (TDD for Skills)
+
+Treat skill authoring as Test-Driven Development applied to agent behavior. Never write speculative lectures for failure modes you have not observed:
+
+1. **RED — Baseline Pressure Run (Without Skill):**
+   - Dispatch an isolated subagent with a realistic pressure scenario (time urgency, sunk-cost framing, or a tempting shortcut) *without* loading the target skill.
+   - Record the exact rationalizations and shortcuts the model takes.
+2. **GREEN — Minimal Counter-Rule:**
+   - Add only the specific blocking gate, decision table row, or hook pattern needed to defeat those observed rationalizations.
+   - Re-run the same pressure prompt on a fresh subagent *with* the skill loaded and verify full compliance.
+3. **REFACTOR — Close Loopholes Within Budget:**
+   - Tighten ambiguous phrasing while keeping `SKILL.md` strictly within the 150-line router budget and 1-hop reference limit.
+

package/.agents/plugins/agentic-senior-core/skills/asc-develop/SKILL.md

@@ -1,84 +1,69 @@
 ---
 name: asc-develop
 description: >
-  Trigger this skill when the user is: building a new feature, creating an endpoint, adding components, scaffolding a new project, starting from scratch, or refactoring existing code. Trigger when the user says: "add a feature", "build this endpoint", "implement this", "extend this", "wire up", "create a new route", "add a new page", "tambah fitur", "bikin endpoint", "new project", "start from scratch", "scaffold this", "bootstrap app", "bikin project baru", "buat aplikasi baru", "refactor this", "clean up this code", "rewrite this", "extract this into", "simplify this module", "rapikan kode ini", "refactor ini".
+  Trigger this skill when the user is: building a new feature, creating an endpoint, planning multi-step tasks, dispatching subagents, scaffolding a new project, or refactoring existing code. Trigger when the user says: "add a feature", "build this endpoint", "make a plan", "break down tasks", "implement this", "wire up", "new project", "scaffold this", "refactor this", "clean up this code", "tambah fitur", "bikin endpoint", "bikin plan", "pecah task", "bikin project baru", "rapikan kode ini", "refactor ini".
 ---
 
-# Engineering Lifecycle Playbook (`asc-develop`)
+# Engineering Lifecycle & Execution Router (`asc-develop`)
 
-Universal engineering workflow for greenfield development, feature implementation, and structured refactoring. Enforces strict specification alignment, analog module reuse, and automated validation without cluttering repositories with disk checkpoint files.
-
-Grounded in: Fowler's Refactoring, Spec-Driven Development (SDD), and HumanLayer RPI.
+Universal workflow for greenfield scaffolding, feature planning/implementation, subagent orchestration, and refactoring without repository disk clutter.
 
 ---
 
-## Mode 1: Greenfield (New Project Scaffolding)
+## 0. Mandatory 1-Hop Pre-Flight Gate (BLOCKING)
+
+> [!IMPORTANT]
+> Paths below are relative to this `SKILL.md` directory (`.../skills/asc-develop/`). Prepend this skill's folder path when calling `read_file`.
 
-Use when creating a new application, service, or repository from zero.
+Before drafting multi-step plans, asking clarifying questions, or dispatching subagents:
+1. **Multi-step feature, architecture plan, or continuous task execution** $\rightarrow$ **MUST** `read_file` `references/execution-plans.md` first (*Look Before You Ask*, exact signatures, and *Rulings, Not Stalls*).
+2. **Executing $\ge$ 2 independent module tasks or parallel branches** $\rightarrow$ **MUST** `read_file` `references/subagent-orchestration.md` first (fresh context isolation, 2-pass review gate, `git worktree`).
 
-### Step 1: Define & Clarify (No Code)
-1. Clarify essential project requirements with the user: target runtime, platform, frameworks, performance bounds, and explicit non-goals.
-2. Propose the top-level directory layout and module boundaries following idiomatic conventions of the chosen stack.
-3. Present an architectural summary and wait for user alignment before writing files.
+---
+
+## Mode 1: Greenfield (New Project Scaffolding)
 
-### Step 2: Implementation & Decision Ladder
-1. Apply the ASC Decision Ladder to every module:
-   - Does this need to be built?
-   - Can standard library or native platform handle it?
-   - Can this be one straightforward function?
-2. Build the core domain entities, data models, and services first before protocol/transport controllers.
-3. For frontend interfaces, follow `/asc-ui`. For documentation and prose (READMEs, ADRs), enforce the Universal Prose Floor (zero AI throat-clearing, 50% word reduction, zero buzzwords).
-4. Generate a quality gate workflow (e.g., `.github/workflows/quality-gate.yml`) that runs linter, type-check, and tests.
+### Step 1: Define & Clarify (Look Before You Ask)
+1. Clarify only unresolved requirements (target runtime, frameworks, non-goals) in at most one focused question with 2–3 concrete options.
+2. Propose top-level directory layout and exact module contracts; confirm alignment before writing files.
 
-### Step 3: Validation
-1. Verify acceptance criteria against the initial specification.
-2. Confirm no unnecessary dependencies or speculative abstractions were introduced.
+### Step 2: Architecture & Implementation Hierarchy
+1. Apply the 1–6 Decision Ladder to every module (needed $\rightarrow$ reuse $\rightarrow$ stdlib $\rightarrow$ installed dep $\rightarrow$ single function $\rightarrow$ minimal code).
+2. Implement core domain models and services before transport controllers.
+3. For frontend views, follow `/asc-ui`. Enforce clean single-language prose (50% word reduction, zero marketing buzzwords).
+4. Add an automated quality gate workflow (lint, type-check, test).
 
 ---
 
 ## Mode 2: Brownfield (Feature Implementation)
 
-Use when adding endpoints, components, pages, or capabilities to an existing codebase.
+### Step 1: Research & Reuse Inventory
+1. Inspect analogous modules for layer splits, naming conventions, validation, and error handling.
+2. Identify existing components (`components/ui/`), helpers, and notification providers that must **NOT** be rebuilt.
 
-### Step 1: Research (Codebase & Pattern Inventory)
-1. Map existing code: scan analogous modules to inspect their layer split, naming conventions, error handling, and notification patterns.
-2. **Reuse Inventory**: Identify existing shared components (`components/`, `ui/`), utility functions, and active toast/banner providers. Explicitly decide what must **NOT** be rebuilt.
-3. Present a factual research summary identifying reused components and implementation direction. Stop and confirm before implementing.
+### Step 2: Right-Sized Plan & Fallback Matrix
+1. Break work into testable atomic tasks with exact file paths and function signatures (`references/execution-plans.md`).
+2. Define failure handling: network/DB failure recovery, pending UI states, and structured error responses (RFC 9457).
 
-### Step 2: Implementation Plan & Fallback Matrix
-1. Define a step-by-step implementation plan with targeted files and functions.
-2. **Failure Modes & Fallback Matrix**: Define concrete behavior for failure scenarios:
-   - What happens on network/API failure or timeout?
-   - What feedback does the user see? (Pending state, inline field error, toast/banner with retry).
-   - How can the system recover? (Retry, cached fallback, degraded mode).
-3. If building UI or writing documentation, ensure compliance with the Universal Prose Floor and `/asc-ui` (zero marketing fluff, single-language consistency, mobile reflow, WCAG AA contrast).
-
-### Step 3: Implement & Validate (TDD Integration)
-1. Follow the TDD cycle via `/asc-test`: write the failing test first (RED), write minimal code to pass (GREEN), then refactor.
-2. **Zero-Fake-Done Testing**: Run the project test suite (`ascx npm test`, `ascx pytest`, `ascx cargo test`). The test runner **MUST** exit with code 0.
-3. Never weaken or delete test assertions to simulate a passing run. Fix the underlying business logic.
+### Step 3: TDD Implementation & Autonomous Rulings
+1. Execute each task via `/asc-test` (`RED` failing test $\rightarrow$ `GREEN` minimal code $\rightarrow$ `REFACTOR`).
+2. Resolve minor spec ambiguities autonomously using inline `Ruling:` notes (`references/execution-plans.md`); stop only for destructive, security, or external side effects.
+3. Run the test suite fresh (`ascx npm test`, `ascx pytest`, `ascx cargo test`) and confirm `exit 0`.
 
 ---
 
 ## Mode 3: Refactoring (Structure Modernization)
 
-Use when restructuring, simplifying, or modernizing code without changing external behavior.
-
-### Step 1: YAGNI Scan & Baseline Verification
-1. **Verify Baseline**: Run project tests to ensure all existing tests pass before touching code. Do not refactor on broken tests.
-2. **YAGNI Scan**: Identify speculative code to remove:
-   - "Just in case" abstractions wrapping a single implementation with no second consumer.
-   - Dead branches, unused flags, and premature extension points.
-
-### Step 2: Scope & Execution
-1. **Low-Level Refactors** (rename, extract helper, type tightening, dead code removal): Proceed immediately.
-2. **High-Level Refactors** (moving modules, altering architecture boundaries, redesigning contracts): Propose the plan and rationale, then confirm before applying.
-3. Apply Refactor Invariants:
-   - Maintain flat happy paths via early returns over nested `if/else`.
-   - Preserve all user feedback indicators, error notifications, and fallbacks.
-   - Never drop error-handling branches.
-   - Run a final simplification pass.
-
-### Step 3: Verification
-1. Re-run tests to confirm that behavior, public contracts, and error handling remain identical.
-2. For every changed module, confirm that readability, maintainability, and safety have improved.
+1. **Baseline Check:** Run existing tests first; never refactor on a failing baseline.
+2. **YAGNI Scan:** Remove single-consumer wrapper abstractions, dead branches, and unused flags.
+3. **Scope Gate:** Execute local renames/extractions directly; confirm cross-module boundary changes first.
+4. **Invariants:** Flatten happy paths with early returns, preserve all error branches and user feedback states, and re-run the full test suite (`exit 0`).
+
+---
+
+## On-Demand Reference Library
+
+| Lifecycle Requirement | Mandatory Reference Path |
+| :--- | :--- |
+| Discovery, bite-sized plans, exact signatures & `Ruling:` execution | `references/execution-plans.md` |
+| Isolated subagent dispatch, 2-pass Spec/Quality review & `git worktree` | `references/subagent-orchestration.md` |

package/.agents/plugins/agentic-senior-core/skills/asc-develop/references/execution-plans.md

@@ -0,0 +1,43 @@
+# Execution Plans, Discovery & Autonomous Rulings
+
+Structured specification and execution protocol for multi-step features, greenfield builds, and cross-module refactors.
+
+---
+
+## 1. Look Before You Ask (Pre-Plan Discovery)
+
+Before asking clarifying questions or drafting a plan:
+1. **Exhaust Repository Evidence:** Read target routes, controllers, services, schemas, and analogous tests first. Never ask the user a question that `package.json`, database migrations, or existing modules already answer.
+2. **Single-Question Gate:** When genuine product or contract ambiguity remains, ask at most **one** focused question (or one compact multiple-choice prompt). Present 2–3 concrete approaches with explicit operational trade-offs (complexity, schema impact, latency), placing the recommended option first.
+3. **Fast-Path Trivial Tasks:** If every requirement is already explicit in a small single-file request, skip plan ceremony and execute directly with test verification.
+
+---
+
+## 2. Task Right-Sizing & Exact Signatures
+
+Write plans for an engineer with zero prior context of the conversation:
+
+1. **Map File Responsibility First:** List every file to create or modify and its single clear responsibility before decomposing tasks. Respect established repository layout.
+2. **Exact Contracts Up Front:** Specify exact function names, parameter types, return shapes, error codes, and file paths in the plan.
+3. **Testable Task Boundaries:** A task is the smallest unit that delivers an independently testable behavior. Fold config, types, and wiring into the task whose test requires them.
+4. **Atomic 4-Step Task Cycle:**
+   - Write the failing test targeting the exact signature.
+   - Run the test runner and confirm it fails for the expected reason (`RED`).
+   - Write the minimum implementation code required to pass (`GREEN`).
+   - Run the test runner fresh and confirm `exit 0`.
+
+---
+
+## 3. Continuous Execution: Rulings, Not Stalls
+
+Once the user approves a plan (or requests direct execution), execute all tasks continuously without pausing between steps to ask *"Should I continue?"*.
+
+1. **Autonomous Rulings on Minor Ambiguities:** When encountering an implementation detail not explicitly covered by the spec (edge-case defaults, internal helper naming, local validation order), decide immediately using codebase conventions and record the decision inline:
+   - `Ruling: <what was decided> — <technical rationale> — <remediation cost if wrong>`
+   - If the ruling defers non-critical scope via a stub, log it in `.agents/debt-ledger.json`.
+2. **The Four Hard Stop Conditions:** Halt execution and ask the user **only** when hitting:
+   - An irreversible or destructive data/file operation.
+   - A security boundary, authentication, or authorization contract change not approved in the spec.
+   - An external side effect outside the local workspace (`git push`, package publish, production API mutation).
+   - A fundamental contradiction in requirements where every path forward is pure guesswork.
+