@chllming/wave-orchestration 0.5.2 → 0.5.4

package/scripts/wave-orchestrator/traces.mjs

@@ -671,6 +671,29 @@ function buildAgentMetadata(dir, run, attempt, artifacts) {
         run.lastContext7?.snippetHash ||
         (run.lastContext7?.promptText ? hashText(run.lastContext7.promptText) : ""),
     },
+    skills:
+      run.lastSkillProjection ||
+      (run.agent?.skillsResolved
+        ? {
+            ids: run.agent.skillsResolved.ids || [],
+            role: run.agent.skillsResolved.role || null,
+            runtime: run.agent.skillsResolved.runtime || null,
+            deployKind: run.agent.skillsResolved.deployKind || null,
+            promptHash: run.agent.skillsResolved.promptHash || null,
+            bundles: Array.isArray(run.agent.skillsResolved.bundles)
+              ? run.agent.skillsResolved.bundles.map((bundle) => ({
+                  id: bundle.id,
+                  bundlePath: bundle.bundlePath,
+                  manifestPath: bundle.manifestPath,
+                  skillPath: bundle.skillPath,
+                  adapterPath: bundle.adapterPath || null,
+                  bundleHash: bundle.bundleHash || null,
+                  sourceFiles: Array.isArray(bundle.sourceFiles) ? bundle.sourceFiles.slice() : [],
+                }))
+              : [],
+            artifacts: run.agent.skillsResolved.artifacts || null,
+          }
+        : null),
   };
 }
 

package/scripts/wave-orchestrator/wave-files.mjs

@@ -30,6 +30,7 @@ import {
 } from "./shared.mjs";
 import { normalizeContext7Config, hashAgentPromptFingerprint } from "./context7.mjs";
 import {
+  isOpenCoordinationStatus,
   openClarificationLinkedRequests,
   readMaterializedCoordinationState,
 } from "./coordination-store.mjs";
@@ -42,6 +43,7 @@ import {
   validateIntegrationSummary,
   validateImplementationSummary,
 } from "./agent-state.mjs";
+import { normalizeSkillId, resolveAgentSkills } from "./skills.mjs";
 
 export const WAVE_EVALUATOR_ROLE_PROMPT_PATH = DEFAULT_EVALUATOR_ROLE_PROMPT_PATH;
 export const WAVE_INTEGRATION_ROLE_PROMPT_PATH = DEFAULT_INTEGRATION_ROLE_PROMPT_PATH;
@@ -201,6 +203,76 @@ function parsePathList(blockText, filePath, label) {
   return paths;
 }
 
+function parseSkillsList(blockText, filePath, label) {
+  if (!blockText) {
+    return [];
+  }
+  const skills = [];
+  const seen = new Set();
+  for (const line of String(blockText || "").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const bulletMatch = trimmed.match(/^-\s+(.+?)\s*$/);
+    if (!bulletMatch) {
+      throw new Error(`Malformed skill entry "${trimmed}" in ${label} (${filePath})`);
+    }
+    const skillId = normalizeSkillId(
+      bulletMatch[1].replace(/[`"']/g, "").trim(),
+      `${label} (${filePath})`,
+    );
+    if (seen.has(skillId)) {
+      throw new Error(`Duplicate skill "${skillId}" in ${label} (${filePath})`);
+    }
+    seen.add(skillId);
+    skills.push(skillId);
+  }
+  return skills;
+}
+
+function parseDeployEnvironments(blockText, filePath) {
+  if (!blockText) {
+    return [];
+  }
+  const environments = [];
+  const seen = new Set();
+  for (const line of String(blockText || "").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const match = trimmed.match(
+      /^-\s+`?([a-z0-9][a-z0-9._-]*)`?\s*:\s*`?([a-z0-9][a-z0-9._-]*)`?\s*(default)?(?:\s+\((.*)\))?$/i,
+    );
+    if (!match) {
+      throw new Error(`Malformed deploy environment "${trimmed}" in ${filePath}`);
+    }
+    const id = String(match[1] || "").trim().toLowerCase();
+    const kind = String(match[2] || "").trim().toLowerCase();
+    if (seen.has(id)) {
+      throw new Error(`Duplicate deploy environment "${id}" in ${filePath}`);
+    }
+    seen.add(id);
+    environments.push({
+      id,
+      kind,
+      isDefault: cleanBooleanToken(match[3]),
+      notes: String(match[4] || "").trim() || null,
+    });
+  }
+  if (!environments.some((environment) => environment.isDefault) && environments.length > 0) {
+    environments[0].isDefault = true;
+  }
+  return environments;
+}
+
+function cleanBooleanToken(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase() === "default";
+}
+
 function normalizeRepoRelativePath(relPath) {
   return String(relPath || "")
     .replaceAll("\\", "/")
@@ -259,6 +331,13 @@ export function extractPromptFromSection(sectionText, filePath, agentId) {
   return extractFencedBlock(promptBlock, `Agent ${agentId} in ${filePath}`);
 }
 
+function extractAgentSkillsFromSection(sectionText, filePath, agentId) {
+  const skillsBlock = extractSectionBody(sectionText, "Skills", filePath, agentId, {
+    required: false,
+  });
+  return parseSkillsList(skillsBlock, filePath, `agent ${agentId} skills`);
+}
+
 function parseContext7Settings(blockText, filePath, label) {
   if (!blockText) {
     return null;
@@ -1280,6 +1359,7 @@ export function parseWaveContent(content, filePath, options = {}) {
     const executorConfig = extractExecutorConfigFromSection(sectionText, filePath, current.agentId);
     const components = extractAgentComponentsFromSection(sectionText, filePath, current.agentId);
     const capabilities = extractAgentCapabilitiesFromSection(sectionText, filePath, current.agentId);
+    const skills = extractAgentSkillsFromSection(sectionText, filePath, current.agentId);
     const deliverables = extractAgentDeliverablesFromSection(
       sectionText,
       filePath,
@@ -1309,6 +1389,7 @@ export function parseWaveContent(content, filePath, options = {}) {
       executorConfig,
       components,
       capabilities,
+      skills,
       deliverables,
       ownedPaths,
     });
@@ -1329,6 +1410,12 @@ export function parseWaveContent(content, filePath, options = {}) {
     wave: waveNumber,
     file: path.relative(REPO_ROOT, filePath),
     commitMessage: commitMessageMatch ? commitMessageMatch[1] : null,
+    deployEnvironments: parseDeployEnvironments(
+      extractTopLevelSectionBody(content, "Deploy environments", filePath, {
+        required: false,
+      }),
+      filePath,
+    ),
     context7Defaults: extractWaveContext7Defaults(content, filePath),
     componentPromotions,
     agents: agentsWithComponentTargets,
@@ -1608,11 +1695,19 @@ export function resolveAgentExecutor(agent, options = {}) {
 }
 
 export function applyExecutorSelectionsToWave(wave, options = {}) {
-  return {
+  const laneProfile = resolveLaneProfileForOptions(options);
+  const withExecutors = {
     ...wave,
     agents: wave.agents.map((agent) => ({
       ...agent,
-      executorResolved: resolveAgentExecutor(agent, options),
+      executorResolved: resolveAgentExecutor(agent, { ...options, laneProfile }),
+    })),
+  };
+  return {
+    ...withExecutors,
+    agents: withExecutors.agents.map((agent) => ({
+      ...agent,
+      skillsResolved: resolveAgentSkills(agent, withExecutors, { laneProfile }),
     })),
   };
 }
@@ -1878,7 +1973,21 @@ export function readWaveEvaluatorArtifacts(wave, { logsDir, evaluatorAgentId } =
   };
 }
 
-export function completedWavesFromStatusFiles(allWaves, statusDir, options = {}) {
+function pushWaveCompletionReason(reasons, code, detail) {
+  const normalizedCode = String(code || "").trim();
+  const normalizedDetail = String(detail || "").trim();
+  if (!normalizedCode || !normalizedDetail) {
+    return;
+  }
+  if (
+    reasons.some((reason) => reason.code === normalizedCode && reason.detail === normalizedDetail)
+  ) {
+    return;
+  }
+  reasons.push({ code: normalizedCode, detail: normalizedDetail });
+}
+
+function analyzeWaveCompletionFromStatusFiles(wave, statusDir, options = {}) {
   const logsDir = options.logsDir || path.join(path.resolve(statusDir, ".."), "logs");
   const coordinationDir =
     options.coordinationDir || path.join(path.resolve(statusDir, ".."), "coordination");
@@ -1893,96 +2002,195 @@ export function completedWavesFromStatusFiles(allWaves, statusDir, options = {})
   const componentThreshold =
     options.requireComponentPromotionsFromWave ??
     laneProfile.validation.requireComponentPromotionsFromWave;
-  const completed = [];
-  for (const wave of allWaves) {
-    let waveIsComplete = wave.agents.length > 0;
-    const summariesByAgentId = {};
-    for (const agent of wave.agents) {
-      const statusPath = path.join(statusDir, `wave-${wave.wave}-${agent.slug}.status`);
-      const statusRecord = readStatusRecordIfPresent(statusPath);
-      if (!statusRecord) {
-        waveIsComplete = false;
-        break;
-      }
-      const expectedPromptHash = hashAgentPromptFingerprint(agent);
-      if (statusRecord.code !== 0 || statusRecord.promptHash !== expectedPromptHash) {
-        waveIsComplete = false;
-        break;
-      }
-      const summary = readAgentExecutionSummary(statusPath);
-      summariesByAgentId[agent.agentId] = summary;
-      if (agent.agentId === evaluatorAgentId && summary) {
-        if (!validateEvaluatorSummary(agent, summary).ok) {
-          waveIsComplete = false;
-          break;
-        }
-        continue;
-      }
-      if (
-        agent.agentId === integrationAgentId &&
-        integrationThreshold !== null &&
-        wave.wave >= integrationThreshold
-      ) {
-        if (!validateIntegrationSummary(agent, summary).ok) {
-          waveIsComplete = false;
-          break;
-        }
-        continue;
-      }
-      if (agent.agentId === documentationAgentId) {
-        if (!validateDocumentationClosureSummary(agent, summary).ok) {
-          waveIsComplete = false;
-          break;
+
+  const reasons = [];
+  const summariesByAgentId = {};
+  const missingStatusAgents = [];
+  let statusesReady = wave.agents.length > 0;
+
+  for (const agent of wave.agents) {
+    const statusPath = path.join(statusDir, `wave-${wave.wave}-${agent.slug}.status`);
+    const statusRecord = readStatusRecordIfPresent(statusPath);
+    if (!statusRecord) {
+      missingStatusAgents.push(agent.agentId);
+      statusesReady = false;
+      continue;
+    }
+    const expectedPromptHash = hashAgentPromptFingerprint(agent);
+    if (statusRecord.code !== 0) {
+      pushWaveCompletionReason(
+        reasons,
+        "nonzero-status",
+        `${agent.agentId} exited ${statusRecord.code} in ${path.relative(REPO_ROOT, statusPath)}.`,
+      );
+      statusesReady = false;
+      continue;
+    }
+    if (statusRecord.promptHash !== expectedPromptHash) {
+      pushWaveCompletionReason(
+        reasons,
+        "prompt-hash-mismatch",
+        `${agent.agentId} status in ${path.relative(REPO_ROOT, statusPath)} does not match the current prompt fingerprint.`,
+      );
+      statusesReady = false;
+      continue;
+    }
+    const summary = readAgentExecutionSummary(statusPath);
+    summariesByAgentId[agent.agentId] = summary;
+    if (agent.agentId === evaluatorAgentId) {
+      if (summary) {
+        const validation = validateEvaluatorSummary(agent, summary);
+        if (!validation.ok) {
+          pushWaveCompletionReason(
+            reasons,
+            "invalid-evaluator-summary",
+            `${agent.agentId}: ${validation.statusCode}: ${validation.detail}`,
+          );
+          statusesReady = false;
         }
-        continue;
-      }
-      if (!validateImplementationSummary(agent, summary).ok) {
-        waveIsComplete = false;
-        break;
       }
+      continue;
     }
     if (
-      waveIsComplete &&
-      componentThreshold !== null &&
-      wave.wave >= componentThreshold &&
-      !validateWaveComponentPromotions(wave, summariesByAgentId, options).ok
+      agent.agentId === integrationAgentId &&
+      integrationThreshold !== null &&
+      wave.wave >= integrationThreshold
     ) {
-      waveIsComplete = false;
+      const validation = validateIntegrationSummary(agent, summary);
+      if (!validation.ok) {
+        pushWaveCompletionReason(
+          reasons,
+          "invalid-integration-summary",
+          `${agent.agentId}: ${validation.statusCode}: ${validation.detail}`,
+        );
+        statusesReady = false;
+      }
+      continue;
     }
-    if (
-      waveIsComplete &&
-      componentThreshold !== null &&
-      wave.wave >= componentThreshold &&
-      !validateWaveComponentMatrixCurrentLevels(wave, { ...options, laneProfile }).ok
-    ) {
-      waveIsComplete = false;
+    if (agent.agentId === documentationAgentId) {
+      const validation = validateDocumentationClosureSummary(agent, summary);
+      if (!validation.ok) {
+        pushWaveCompletionReason(
+          reasons,
+          "invalid-documentation-summary",
+          `${agent.agentId}: ${validation.statusCode}: ${validation.detail}`,
+        );
+        statusesReady = false;
+      }
+      continue;
     }
-    if (
-      waveIsComplete &&
-      !readWaveEvaluatorArtifacts(wave, { logsDir, evaluatorAgentId }).ok
-    ) {
-      waveIsComplete = false;
+    const validation = validateImplementationSummary(agent, summary);
+    if (!validation.ok) {
+      pushWaveCompletionReason(
+        reasons,
+        "invalid-implementation-summary",
+        `${agent.agentId}: ${validation.statusCode}: ${validation.detail}`,
+      );
+      statusesReady = false;
+    }
+  }
+
+  if (missingStatusAgents.length > 0) {
+    pushWaveCompletionReason(
+      reasons,
+      "missing-status",
+      `Missing status files for ${missingStatusAgents.join(", ")}.`,
+    );
+  }
+
+  if (
+    statusesReady &&
+    componentThreshold !== null &&
+    wave.wave >= componentThreshold
+  ) {
+    const promotionsValidation = validateWaveComponentPromotions(wave, summariesByAgentId, options);
+    if (!promotionsValidation.ok) {
+      pushWaveCompletionReason(
+        reasons,
+        "component-promotions-invalid",
+        promotionsValidation.detail,
+      );
+      statusesReady = false;
     }
-    if (waveIsComplete) {
-      const coordinationState = readMaterializedCoordinationState(
-        path.join(coordinationDir, `wave-${wave.wave}.jsonl`),
+    const matrixValidation = validateWaveComponentMatrixCurrentLevels(wave, {
+      ...options,
+      laneProfile,
+    });
+    if (!matrixValidation.ok) {
+      pushWaveCompletionReason(
+        reasons,
+        "component-matrix-invalid",
+        matrixValidation.detail,
       );
-      if (
-        coordinationState.clarifications.some((record) =>
-          ["open", "acknowledged", "in_progress"].includes(record.status),
-        ) ||
-        openClarificationLinkedRequests(coordinationState).length > 0 ||
-        coordinationState.humanEscalations.some((record) =>
-          ["open", "acknowledged", "in_progress"].includes(record.status),
-        ) ||
-        coordinationState.humanFeedback.some((record) =>
-          ["open", "acknowledged", "in_progress"].includes(record.status),
-        )
-      ) {
-        waveIsComplete = false;
-      }
+      statusesReady = false;
     }
-    if (waveIsComplete) {
+  }
+
+  if (statusesReady) {
+    const evaluatorArtifacts = readWaveEvaluatorArtifacts(wave, {
+      logsDir,
+      evaluatorAgentId,
+    });
+    if (!evaluatorArtifacts.ok) {
+      pushWaveCompletionReason(reasons, evaluatorArtifacts.statusCode, evaluatorArtifacts.detail);
+      statusesReady = false;
+    }
+  }
+
+  const coordinationState = readMaterializedCoordinationState(
+    path.join(coordinationDir, `wave-${wave.wave}.jsonl`),
+  );
+  const openClarificationIds = coordinationState.clarifications
+    .filter((record) => isOpenCoordinationStatus(record.status))
+    .map((record) => record.id);
+  if (openClarificationIds.length > 0) {
+    pushWaveCompletionReason(
+      reasons,
+      "open-clarification",
+      `Open clarification records: ${openClarificationIds.join(", ")}.`,
+    );
+  }
+  const openClarificationRequestIds = openClarificationLinkedRequests(coordinationState).map(
+    (record) => record.id,
+  );
+  if (openClarificationRequestIds.length > 0) {
+    pushWaveCompletionReason(
+      reasons,
+      "open-clarification-request",
+      `Open clarification-linked requests: ${openClarificationRequestIds.join(", ")}.`,
+    );
+  }
+  const openHumanEscalationIds = coordinationState.humanEscalations
+    .filter((record) => isOpenCoordinationStatus(record.status))
+    .map((record) => record.id);
+  if (openHumanEscalationIds.length > 0) {
+    pushWaveCompletionReason(
+      reasons,
+      "open-human-escalation",
+      `Open human escalation records: ${openHumanEscalationIds.join(", ")}.`,
+    );
+  }
+  const openHumanFeedbackIds = coordinationState.humanFeedback
+    .filter((record) => isOpenCoordinationStatus(record.status))
+    .map((record) => record.id);
+  if (openHumanFeedbackIds.length > 0) {
+    pushWaveCompletionReason(
+      reasons,
+      "open-human-feedback",
+      `Open human feedback records: ${openHumanFeedbackIds.join(", ")}.`,
+    );
+  }
+
+  return {
+    ok: reasons.length === 0,
+    reasons,
+  };
+}
+
+export function completedWavesFromStatusFiles(allWaves, statusDir, options = {}) {
+  const completed = [];
+  for (const wave of allWaves) {
+    if (analyzeWaveCompletionFromStatusFiles(wave, statusDir, options).ok) {
       completed.push(wave.wave);
     }
   }
@@ -1990,7 +2198,13 @@ export function completedWavesFromStatusFiles(allWaves, statusDir, options = {})
 }
 
 export function reconcileRunStateFromStatusFiles(allWaves, runStatePath, statusDir, options = {}) {
-  const completedFromStatus = completedWavesFromStatusFiles(allWaves, statusDir, options);
+  const diagnostics = allWaves.map((wave) => ({
+    wave: wave.wave,
+    ...analyzeWaveCompletionFromStatusFiles(wave, statusDir, options),
+  }));
+  const completedFromStatus = diagnostics
+    .filter((diagnostic) => diagnostic.ok)
+    .map((diagnostic) => diagnostic.wave);
   const before = readRunState(runStatePath);
   const firstMerge = normalizeCompletedWaves([...before.completedWaves, ...completedFromStatus]);
   const latest = readRunState(runStatePath);
@@ -2003,6 +2217,7 @@ export function reconcileRunStateFromStatusFiles(allWaves, runStatePath, statusD
     completedFromStatus,
     addedFromBefore: firstMerge.filter((waveNumber) => !before.completedWaves.includes(waveNumber)),
     addedFromLatest: merged.filter((waveNumber) => !latest.completedWaves.includes(waveNumber)),
+    blockedFromStatus: diagnostics.filter((diagnostic) => !diagnostic.ok),
     state,
   };
 }

package/scripts/wave.mjs

@@ -14,6 +14,9 @@ function printHelp() {
   wave upgrade [options]
   wave changelog [options]
   wave doctor [options]
+  wave project setup [options]
+  wave project show [options]
+  wave draft [draft options]
   wave launch [launcher options]
   wave autonomous [autonomous options]
   wave feedback [feedback options]
@@ -40,6 +43,14 @@ if (["init", "upgrade", "changelog", "doctor"].includes(subcommand)) {
     console.error(`[wave] ${error instanceof Error ? error.message : String(error)}`);
     process.exit(Number.isInteger(error?.exitCode) ? error.exitCode : 1);
   }
+} else if (subcommand === "project" || subcommand === "draft") {
+  try {
+    const { runPlannerCli } = await import("./wave-orchestrator/planner.mjs");
+    await runPlannerCli([subcommand, ...rest]);
+  } catch (error) {
+    console.error(`[wave] ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(Number.isInteger(error?.exitCode) ? error.exitCode : 1);
+  }
 } else if (subcommand === "launch") {
   try {
     const { runLauncherCli } = await import("./wave-orchestrator/launcher.mjs");

package/skills/provider-aws/SKILL.md

@@ -0,0 +1,6 @@
+# AWS
+
+- Name the exact AWS service, account, region, and resource involved.
+- Prefer explicit CLI or console-equivalent evidence for deployment and environment state.
+- Separate IAM or identity issues from workload health or rollout issues.
+- If AWS state is inferred indirectly, mark the proof gap instead of implying live verification.

package/skills/provider-aws/skill.json

@@ -0,0 +1,5 @@
+{
+  "id": "provider-aws",
+  "title": "AWS",
+  "description": "AWS environment and rollout norms."
+}

package/skills/provider-custom-deploy/SKILL.md

@@ -0,0 +1,5 @@
+# Custom Deploy
+
+- Make the custom environment contract explicit before treating it as proved.
+- Name the exact verification surface, command, or operator artifact used as evidence.
+- If the environment lacks a stable verification path, record the resulting deploy risk.

package/skills/provider-custom-deploy/skill.json

@@ -0,0 +1,5 @@
+{
+  "id": "provider-custom-deploy",
+  "title": "Custom Deploy",
+  "description": "Fallback deploy norms for custom environments."
+}

package/skills/provider-docker-compose/SKILL.md

@@ -0,0 +1,6 @@
+# Docker Compose
+
+- Use compose file names, service names, ports, and health checks exactly.
+- Distinguish local container health from production readiness.
+- Record the exact compose commands or logs used as proof.
+- Make service dependency and readiness ordering explicit when rollout depends on it.

package/skills/provider-docker-compose/skill.json

@@ -0,0 +1,5 @@
+{
+  "id": "provider-docker-compose",
+  "title": "Docker Compose",
+  "description": "Docker Compose environment and rollout norms."
+}

package/skills/provider-github-release/SKILL.md

@@ -0,0 +1,6 @@
+# GitHub Release
+
+- Keep tag names, release ids, asset names, and notes exact.
+- Distinguish draft, prerelease, and published release state explicitly.
+- Treat release notes, attached artifacts, and publication state as separate proof surfaces.
+- If publication depends on another deploy system, keep that dependency explicit.

package/skills/provider-github-release/skill.json

@@ -0,0 +1,5 @@
+{
+  "id": "provider-github-release",
+  "title": "GitHub Release",
+  "description": "GitHub release and tag publication norms."
+}

package/skills/provider-kubernetes/SKILL.md

@@ -0,0 +1,6 @@
+# Kubernetes
+
+- Name the exact cluster, namespace, workload, and rollout surface involved.
+- Prefer explicit `kubectl` state, health, and event evidence over generic rollout notes.
+- Distinguish manifest drift, admission failure, image failure, and readiness failure.
+- If rollback or restart is involved, make the operator-visible recovery posture explicit.

package/skills/provider-kubernetes/skill.json

@@ -0,0 +1,5 @@
+{
+  "id": "provider-kubernetes",
+  "title": "Kubernetes",
+  "description": "Kubernetes cluster, workload, and rollout norms."
+}

package/skills/provider-railway/SKILL.md

@@ -0,0 +1,6 @@
+# Railway
+
+- Prefer the Railway MCP or Railway CLI as the source of truth for deployment, environment, and service state.
+- Keep service names, environment names, domains, and deployment ids exact.
+- Record what was verified: build logs, deploy logs, variables, domains, or rollout state.
+- If Railway state is degraded or ambiguous, leave a concrete deploy risk instead of implying healthy rollout.

package/skills/provider-railway/adapters/claude.md

@@ -0,0 +1 @@
+Prefer Railway MCP or CLI commands that produce exact deployment, environment, and service evidence. Avoid vague rollout claims without Railway-backed proof.

package/skills/provider-railway/adapters/codex.md

@@ -0,0 +1 @@
+Use Railway MCP tools when they are available in-session. Fall back to the Railway CLI only when MCP coverage is missing or insufficient.

package/skills/provider-railway/adapters/local.md

@@ -0,0 +1 @@
+The local runtime cannot prove live Railway state. Limit output to prompt smoke validation and identify any missing live verification.

package/skills/provider-railway/adapters/opencode.md

@@ -0,0 +1 @@
+Use injected Railway files and commands as the authoritative path for service and deployment verification. Keep Railway identifiers exact in output.

package/skills/provider-railway/skill.json

@@ -0,0 +1,5 @@
+{
+  "id": "provider-railway",
+  "title": "Railway",
+  "description": "Railway-specific deploy and environment norms."
+}

package/skills/provider-ssh-manual/SKILL.md

@@ -0,0 +1,6 @@
+# SSH Manual
+
+- Treat manual host access as high-risk and fail closed on missing proof.
+- Record the exact host or surface touched and the exact checks performed.
+- Avoid destructive manual changes unless explicitly approved by the task and repo policy.
+- Convert shell observations into explicit environment or deploy status markers.

package/skills/provider-ssh-manual/skill.json

@@ -0,0 +1,5 @@
+{
+  "id": "provider-ssh-manual",
+  "title": "SSH Manual",
+  "description": "Manual host and SSH-based environment norms."
+}

package/skills/repo-coding-rules/SKILL.md

@@ -0,0 +1,7 @@
+# Repo Coding Rules
+
+- Read `AGENTS.md` before making material edits if it exists.
+- Prefer small, reviewable changes that preserve existing repo patterns.
+- Run the relevant tests or checks for touched surfaces and fix regressions caused by your changes.
+- Keep docs aligned when implementation changes status, ownership, or proof expectations.
+- Do not push by default unless the task explicitly asks for it.

package/skills/repo-coding-rules/skill.json

@@ -0,0 +1,5 @@
+{
+  "id": "repo-coding-rules",
+  "title": "Repo Coding Rules",
+  "description": "Repository-local coding and validation rules."
+}