@bonesofspring/ai-rules 0.2.2 → 0.2.4

package/presets/claude/ios-swift/hooks/chain-team-phases.sh

@@ -0,0 +1,382 @@
+#!/usr/bin/env bash
+# Chains agent team steps from pipeline.json after subagentStop.
+# Falls back to legacy phase-based flow when pipeline.json is absent.
+
+set -euo pipefail
+
+input=$(cat)
+
+INPUT="$input" node <<'NODE'
+const fs = require('fs');
+const path = require('path');
+
+const TEAM_ROOT = path.join(process.cwd(), '.claude', 'team');
+
+const inputRaw = process.env.INPUT || '';
+let hookInput;
+try {
+  hookInput = JSON.parse(inputRaw);
+} catch {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+if (hookInput.status !== 'completed') {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+const activePath = path.join(TEAM_ROOT, 'active-task.json');
+
+if (!fs.existsSync(activePath)) {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+let active;
+try {
+  active = JSON.parse(fs.readFileSync(activePath, 'utf8'));
+} catch {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+const slug = active.slug;
+if (!slug) {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+const taskDir = path.join(TEAM_ROOT, 'tasks', slug);
+const statusPath = path.join(taskDir, 'status.json');
+const pipelinePath = path.join(taskDir, 'pipeline.json');
+
+if (!fs.existsSync(statusPath)) {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+let status;
+try {
+  status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+} catch {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+const now = new Date().toISOString();
+
+function writeStatus(next) {
+  status = { ...status, ...next, slug, updatedAt: now };
+  fs.writeFileSync(statusPath, JSON.stringify(status, null, 2) + '\n');
+}
+
+function out(message) {
+  process.stdout.write(JSON.stringify({ followup_message: message }));
+}
+
+function readArtifact(name) {
+  const p = path.join(taskDir, name);
+  if (!fs.existsSync(p)) return '';
+  try {
+    return fs.readFileSync(p, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function getStepAgents(step) {
+  if (!step) return [];
+  return Array.isArray(step.agent) ? step.agent : [step.agent];
+}
+
+function skipIfMatches(skipIf, dir) {
+  if (!skipIf) return false;
+  if (skipIf === 'debugger.fixed') {
+    const text = readArtifact('debug-report.md');
+    return /fixApplied:\s*true/i.test(text) || /\*\*Fix applied:\*\*\s*true/i.test(text);
+  }
+  if (skipIf === 'ci-investigator.resolved') {
+    const text = readArtifact('ci-report.md');
+    return /fixApplied:\s*true/i.test(text) || /## Verdict\s*\nPASS/i.test(text);
+  }
+  return false;
+}
+
+function findNextExecutableStep(steps, startIdx, dir) {
+  for (let i = startIdx; i < steps.length; i++) {
+    if (!skipIfMatches(steps[i].skipIf, dir)) {
+      return { step: steps[i], index: i };
+    }
+  }
+  return null;
+}
+
+const AGENT_HANDOFF = {
+  'task-analyst': (s) =>
+    `Invoke task-analyst for slug "${s}". Write brief.md and decomposition.md under .claude/team/tasks/${s}/. ` +
+    `Set status.json: phase executing, state awaiting_approval if human gate applies. Do not use legacy phase analysis.`,
+  debugger: (s) =>
+    `Invoke debugger subagent for slug "${s}". Investigate root cause; write debug-report.md with fixApplied: true/false. ` +
+    `Update status.json when done.`,
+  'solution-architect': (s) =>
+    `Invoke solution-architect for slug "${s}". Read brief.md; write architecture.md. Update status.json when done.`,
+  'migration-specialist': (s) =>
+    `Invoke migration-specialist for slug "${s}". Read brief.md; write migration-plan.md. Update status.json when done.`,
+  'api-contract-reviewer': (s) =>
+    `Invoke api-contract-reviewer (readonly) for slug "${s}". Write api-contract-review.md. Update status.json when done.`,
+  'ci-investigator': (s) =>
+    `Invoke ci-investigator for slug "${s}". Diagnose CI failure; write ci-report.md; apply minimal fix. ` +
+    `Use ci-investigation skill. Update status.json when done.`,
+  'feature-developer': (s) =>
+    `Invoke feature-developer for slug "${s}". Read brief.md, decomposition.md, validation-report.md, review.md, architecture.md, migration-plan.md, api-contract-review.md, debug-report.md if present. ` +
+    `Follow feature-delivery-workflow.mdc and reference-features.mdc. Prefer Features/Presentation/Domain/Data (or SPM module) paths over app/src. ` +
+    `Include XCTest/Swift Testing unit coverage for mappers/logic before handoff. Update status.json when done.`,
+  'build-verifier': (s) =>
+    `Invoke build-verifier (readonly) for slug "${s}". Follow xcode-tooling.mdc and post-change-build.mdc. ` +
+    `Run xcodebuild (or swift build/test for SPM-only), SwiftLint/SwiftFormat if configured, and targeted unit smoke — never yarn/ESLint/Stylelint from app/. ` +
+    `Write validation-report.md. Set state completed or validation_failed. Do not edit production code.`,
+  'accessibility-reviewer': (s) =>
+    `Invoke accessibility-reviewer (readonly) for slug "${s}". Review Presentation/SwiftUI (or UIKit) diff for VoiceOver/Dynamic Type/accessibilityIdentifier; write a11y-review.md. Update status.json when done.`,
+  'performance-auditor': (s) =>
+    `Invoke performance-auditor (readonly) for slug "${s}". Audit launch/SwiftUI performance risks; write perf-report.md. Update status.json when done.`,
+  'code-reviewer': (s) =>
+    `Invoke code-reviewer subagent (readonly) for slug "${s}". Review git diff vs brief.md per code-review-mr.mdc. ` +
+    `Update status.json when done.`,
+  'security-reviewer': (s) =>
+    `Invoke security-reviewer (readonly) for slug "${s}". Write security-review.md. Update status.json when done.`,
+  'qa-tester': (s, scope) =>
+    `Invoke qa-tester for slug "${s}"${scope ? ` (scope: ${scope})` : ''}. ` +
+    `Add/update XCTest and XCUITest (*UITests) per brief. Follow tests-ui.mdc and skill xcuitest-e2e. Update status.json when done.`,
+  'unit-test-planner': (s) =>
+    `Invoke unit-test-planner for slug "${s}". Write unit-test-plan.md for XCTest/Swift Testing. Use unit-testing skill. Update status.json when done.`,
+  'unit-test-generator': (s) =>
+    `Invoke unit-test-generator for slug "${s}". Implement *Tests from unit-test-plan.md. Use unit-testing skill. Update status.json when done.`,
+  'unit-test-healer': (s) =>
+    `Invoke unit-test-healer for slug "${s}". Fix failing unit tests. Use unit-testing and debug-investigation skills. Update status.json when done.`,
+  'xcuitest-test-planner': (s) =>
+    `Invoke xcuitest-test-planner for slug "${s}". Create/update XCUITest plans (*UITests / *.cases.md if used). ` +
+    `Follow tests-ui.mdc and the xcuitest-e2e skill. Do not use Playwright MCP. Update status.json when done.`,
+  'xcuitest-test-generator': (s) =>
+    `Invoke xcuitest-test-generator for slug "${s}". Generate/update *UITests from matching plans/*.cases.md. ` +
+    `Follow tests-ui.mdc and the xcuitest-e2e skill. Do not use Playwright MCP. Update status.json when done.`,
+  'xcuitest-test-healer': (s) =>
+    `Invoke xcuitest-test-healer for slug "${s}". Fix failing/flaky XCUITest while preserving plan assertions. ` +
+    `Follow tests-ui.mdc, xcuitest-e2e, and debug-investigation. Do not use Playwright MCP. Update status.json when done.`,
+  'tech-writer': (s) =>
+    `Invoke tech-writer for slug "${s}". Write documentation.md from task artifacts. Update status.json when done.`,
+};
+
+const REVIEW_AGENTS = new Set([
+  'code-reviewer',
+  'accessibility-reviewer',
+  'security-reviewer',
+  'api-contract-reviewer',
+]);
+
+function handoffForAgent(agent, scope) {
+  const fn = AGENT_HANDOFF[agent];
+  return fn ? fn(slug, scope) : `Invoke ${agent} subagent for slug "${slug}". Update status.json when done.`;
+}
+
+function handoffForParallelStep(step) {
+  const agents = getStepAgents(step);
+  return (
+    `Invoke IN PARALLEL (one message, multiple Task calls): ${agents.join(' AND ')} for slug "${slug}". ` +
+    `Each agent writes its artifact and appends itself to status.json parallelCompleted when done.`
+  );
+}
+
+function hasGateAfter(agent, humanGates) {
+  return Array.isArray(humanGates) && humanGates.includes(`after:${agent}`);
+}
+
+function hasGateAfterStep(step, humanGates) {
+  return getStepAgents(step).some((a) => hasGateAfter(a, humanGates));
+}
+
+function legacyFlow() {
+  if (status.phase === 'analysis') {
+    process.stdout.write('{}');
+    process.exit(0);
+  }
+  if (status.phase === 'development' && (status.state === 'completed' || status.state === 'in_progress')) {
+    writeStatus({ phase: 'executing', state: 'in_progress', currentAgent: 'build-verifier' });
+    out(handoffForAgent('build-verifier'));
+    process.exit(0);
+  }
+  if (status.currentAgent === 'build-verifier' && status.state === 'completed') {
+    writeStatus({ phase: 'executing', state: 'in_progress', currentAgent: 'code-reviewer' });
+    out(handoffForAgent('code-reviewer'));
+    process.exit(0);
+  }
+  if (status.phase === 'review' && status.state === 'completed') {
+    writeStatus({ phase: 'executing', state: 'in_progress', currentAgent: 'qa-tester' });
+    out(handoffForAgent('qa-tester'));
+    process.exit(0);
+  }
+  if (status.state === 'changes_requested' && REVIEW_AGENTS.has(status.currentAgent)) {
+    writeStatus({
+      currentAgent: 'feature-developer',
+      state: 'in_progress',
+      phase: 'executing',
+      retryAfterFix: status.currentAgent,
+    });
+    out(
+      handoffForAgent('feature-developer') +
+        ` After fixes, re-run ${status.currentAgent}.`,
+    );
+    process.exit(0);
+  }
+  if (status.state === 'validation_failed' && status.currentAgent === 'build-verifier') {
+    writeStatus({
+      currentAgent: 'feature-developer',
+      state: 'in_progress',
+      phase: 'executing',
+      retryAfterFix: 'build-verifier',
+    });
+    out(
+      handoffForAgent('feature-developer') +
+        ` Read validation-report.md. After fixes, re-run build-verifier.`,
+    );
+    process.exit(0);
+  }
+  if (status.state === 'completed' && status.retryAfterFix) {
+    const retry = status.retryAfterFix;
+    writeStatus({ currentAgent: retry, state: 'in_progress', retryAfterFix: null });
+    out(handoffForAgent(retry));
+    process.exit(0);
+  }
+  if (status.phase === 'testing' && status.state === 'completed') {
+    writeStatus({ phase: 'done', state: 'completed' });
+    out(`Pipeline complete for "${slug}". Run /technical-retro ${slug}.`);
+    process.exit(0);
+  }
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+if (!fs.existsSync(pipelinePath)) {
+  legacyFlow();
+}
+
+let pipeline;
+try {
+  pipeline = JSON.parse(fs.readFileSync(pipelinePath, 'utf8'));
+} catch {
+  legacyFlow();
+}
+
+const steps = pipeline.steps || [];
+if (steps.length === 0 || pipeline.autoChain === false) {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+if (status.awaitingHumanGate || status.state === 'awaiting_approval') {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+if (status.state === 'changes_requested' && REVIEW_AGENTS.has(status.currentAgent)) {
+  const reviewer = status.currentAgent;
+  writeStatus({
+    currentAgent: 'feature-developer',
+    state: 'in_progress',
+    phase: 'executing',
+    retryAfterFix: reviewer,
+  });
+  out(
+    handoffForAgent('feature-developer') +
+      ` After fixes, re-run ${reviewer}.`,
+  );
+  process.exit(0);
+}
+
+if (status.state === 'validation_failed' && status.currentAgent === 'build-verifier') {
+  writeStatus({
+    currentAgent: 'feature-developer',
+    state: 'in_progress',
+    phase: 'executing',
+    retryAfterFix: 'build-verifier',
+  });
+  out(
+    handoffForAgent('feature-developer') +
+      ` Read validation-report.md. After fixes, re-run build-verifier.`,
+  );
+  process.exit(0);
+}
+
+if (status.state === 'completed' && status.retryAfterFix) {
+  const retry = status.retryAfterFix;
+  writeStatus({ currentAgent: retry, state: 'in_progress', retryAfterFix: null });
+  out(handoffForAgent(retry));
+  process.exit(0);
+}
+
+const idx = typeof status.pipelineIndex === 'number' ? status.pipelineIndex : 0;
+const currentStep = steps[idx];
+if (!currentStep) {
+  writeStatus({ phase: 'done', state: 'completed', currentAgent: null });
+  out(`Pipeline complete for "${slug}". Run /technical-retro ${slug}.`);
+  process.exit(0);
+}
+
+const completedAgent = status.currentAgent || getStepAgents(currentStep)[0];
+const stepAgents = getStepAgents(currentStep);
+
+if (currentStep.parallel && stepAgents.length > 1) {
+  const done = [...(status.parallelCompleted || [])];
+  if (completedAgent && !done.includes(completedAgent)) {
+    done.push(completedAgent);
+  }
+  writeStatus({ parallelCompleted: done });
+  const remaining = stepAgents.filter((a) => !done.includes(a));
+  if (remaining.length > 0) {
+    process.stdout.write('{}');
+    process.exit(0);
+  }
+  writeStatus({ parallelCompleted: [] });
+}
+
+if (hasGateAfterStep(currentStep, pipeline.humanGates)) {
+  writeStatus({
+    awaitingHumanGate: true,
+    state: 'awaiting_approval',
+    currentAgent: completedAgent,
+  });
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+const next = findNextExecutableStep(steps, idx + 1, taskDir);
+if (!next) {
+  writeStatus({
+    pipelineIndex: steps.length,
+    phase: 'done',
+    state: 'completed',
+    currentAgent: null,
+    awaitingHumanGate: false,
+  });
+  out(`Pipeline complete for "${slug}". Run /technical-retro ${slug}.`);
+  process.exit(0);
+}
+
+const { step: nextStep, index: nextIdx } = next;
+const nextAgents = getStepAgents(nextStep);
+
+writeStatus({
+  pipelineIndex: nextIdx,
+  currentAgent: nextAgents[0],
+  phase: 'executing',
+  state: 'in_progress',
+  awaitingHumanGate: false,
+  parallelCompleted: [],
+});
+
+if (nextStep.parallel && nextAgents.length > 1) {
+  out(handoffForParallelStep(nextStep));
+} else {
+  out(handoffForAgent(nextAgents[0], nextStep.scope));
+}
+NODE

package/presets/claude/ios-swift/hooks/guard-shell-command.sh

@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+# Lightweight shell guard for Claude Code projects using this preset.
+# iOS: do NOT blanket-block xcodebuild / simctl / xcrun / swiftlint / swiftformat.
+# Package-manager mismatch checks apply only when a JS lockfile/package.json exists.
+
+set -euo pipefail
+
+input=$(cat)
+
+INPUT="$input" node <<'NODE'
+const fs = require('fs');
+
+const raw = process.env.INPUT || '';
+let event;
+try {
+  event = JSON.parse(raw);
+} catch {
+  process.stdout.write('{ "permission": "allow" }');
+  process.exit(0);
+}
+
+const command = String(event.command || event.input?.command || '');
+if (!command.trim()) {
+  process.stdout.write('{ "permission": "allow" }');
+  process.exit(0);
+}
+
+function out(permission, userMessage, agentMessage) {
+  process.stdout.write(JSON.stringify({
+    permission,
+    user_message: userMessage,
+    agent_message: agentMessage || userMessage,
+  }));
+}
+
+const dangerousGit = /\bgit\s+(reset\s+--hard|clean\s+-[^\n]*f|push\s+--force|push\s+-f|checkout\s+--\s+)/;
+if (dangerousGit.test(command)) {
+  out(
+    'ask',
+    'This command looks destructive for git state. Review it before continuing.',
+    'A project hook flagged a destructive git command. Ask the user before running it.',
+  );
+  process.exit(0);
+}
+
+const managerByFile = [
+  ['yarn.lock', 'yarn'],
+  ['pnpm-lock.yaml', 'pnpm'],
+  ['package-lock.json', 'npm'],
+].find(([file]) => fs.existsSync(file));
+
+let expected = managerByFile?.[1];
+if (!expected && fs.existsSync('package.json')) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    const pm = typeof pkg.packageManager === 'string' ? pkg.packageManager : '';
+    expected = pm.split('@')[0] || undefined;
+  } catch {
+    // Ignore invalid package.json in the hook; the agent can diagnose it later.
+  }
+}
+
+if (!expected) {
+  process.stdout.write('{ "permission": "allow" }');
+  process.exit(0);
+}
+
+const used = command.match(/(^|[;&|]\s*)(npm|yarn|pnpm)\s+/)?.[2];
+if (used && used !== expected) {
+  out(
+    'ask',
+    `This repository appears to use ${expected}, but the command uses ${used}. Confirm before continuing.`,
+    `Use ${expected} for package scripts and installs unless the user explicitly approves ${used}.`,
+  );
+  process.exit(0);
+}
+
+process.stdout.write('{ "permission": "allow" }');
+NODE

package/presets/claude/ios-swift/mcp.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "context7": {
+      "command": "npx",
+      "args": ["-y", "@upstash/context7-mcp"]
+    },
+    "figma": {
+      "type": "http",
+      "url": "https://mcp.figma.com/mcp"
+    }
+  }
+}

package/presets/claude/ios-swift/rules/README.md

@@ -1,19 +1,23 @@
 # `.claude/rules` (preset ios-swift)
 
-В Claude Code все `.md` под `rules/` **обнаруживаются рекурсивно**. Тела правил **derived** из Cursor SoT; индексы (этот README и папочные) — не второй SoT.
+В Claude Code все `.md` под `rules/` **обнаруживаются рекурсивно**. Тела **derived** из Cursor SoT; индексы — не второй SoT.
 
 ## SoT sync
 
 | Principle | Detail |
 |-----------|--------|
 | **SoT** | `presets/cursor/ios-swift/rules/*.mdc` — edit here first |
-| **Derive** | Claude topic `.md` = body of matching `.mdc` + frontmatter `paths:` (from Cursor `globs:`) |
-| **Drop** | Cursor-only keys (`alwaysApply`); keep short `description` where useful |
-| **Do not** | Maintain independent long-form Claude prose that diverges in meaning |
+| **Derive** | Claude topic `.md` = body + `paths:` (from Cursor `globs:` / requestable triggers) |
+| **Drop** | Cursor-only keys (`alwaysApply`); keep short `description` |
+| **Checklist** | change Cursor → update Claude twin **same PR** |
 
-**Checklist:** change Cursor `.mdc` → update Claude twin `.md` in the **same PR**.
+## Loading budget
 
-## Cursor → Claude mapping (12/12)
+- **Session-start (no `paths:`):** ровно **3** — `ios-app-core`, `boundaries`, `code-quality` (≤120 body lines total)
+- **Все остальные** — с `paths:` (commands/team/agents и/или Feature/Swift globs)
+- **Soft twin depth:** domain rules ≥15 body lines; thin aliases (`agent-team-intake`, `technical-retro`) могут быть короче (как next)
+
+## Cursor → Claude mapping
 
 | Cursor `.mdc` (SoT) | Claude topic |
 |---------------------|--------------|
@@ -21,24 +25,31 @@
 | `swift-conventions.mdc` | `stack/swift-conventions.md` |
 | `architecture-boundaries.mdc` | `architecture/boundaries.md` |
 | `feature-delivery-workflow.mdc` | `architecture/feature-delivery.md` |
+| `reference-features.mdc` | `architecture/reference-features.md` |
+| `module-public-api.mdc` | `architecture/module-public-api.md` |
 | `networking-services.mdc` | `api-and-data/networking.md` |
+| `persistence-data.mdc` | `api-and-data/persistence.md` |
 | `swiftui-ui.mdc` | `ui-and-accessibility/swiftui.md` |
 | `state-and-viewmodels.mdc` | `ui-and-accessibility/viewmodels.md` |
+| `navigation-coordinators.mdc` | `ui-and-accessibility/navigation.md` |
 | `tests-unit.mdc` | `testing/unit.md` |
 | `tests-ui.mdc` | `testing/ui.md` |
 | `code-quality-and-refactoring.mdc` | `tooling-and-review/code-quality.md` |
 | `code-review-mr.mdc` | `tooling-and-review/code-review.md` |
 | `post-change-build.mdc` | `tooling-and-review/post-change-build.md` |
+| `xcode-tooling.mdc` | `tooling-and-review/xcode-tooling.md` |
+| `security-ios.mdc` | `tooling-and-review/security-ios.md` |
+| `agent-team-intake.mdc` | `tooling-and-review/agent-team-intake.md` |
+| `agent-team-orchestrator.mdc` | `tooling-and-review/agent-team-orchestrator.md` |
+| `technical-retro.mdc` | `tooling-and-review/technical-retro.md` |
 
 ## Folders
 
 | Папка | О чём |
 |-------|--------|
-| `stack/` | Стек, структура проекта, Swift conventions |
-| `architecture/` | Границы слоёв / DI, доставка фичи |
-| `api-and-data/` | URLSession, DTO, Codable, mappers, repositories |
-| `testing/` | unit (XCTest), UI (XCUITest) |
-| `ui-and-accessibility/` | SwiftUI, Design System, ViewModels |
-| `tooling-and-review/` | Качество кода, code review, post-change build |
-
-Path-scoped rules use frontmatter `paths:` (same patterns as Cursor `globs:`). Rules without `paths:` apply broadly (Claude equivalent of Cursor alwaysApply / requestable).
+| `stack/` | Стек, Swift conventions |
+| `architecture/` | Границы, feature-delivery, reference-features, SPM public API |
+| `api-and-data/` | Networking, persistence |
+| `testing/` | XCTest, XCUITest |
+| `ui-and-accessibility/` | SwiftUI, ViewModels, navigation |
+| `tooling-and-review/` | Quality, review, build, security, tooling, agent-team, retro |

package/presets/claude/ios-swift/rules/api-and-data/README.md

@@ -1,9 +1,10 @@
 # API and data
 
-Сетевой слой, DTO, mappers, repository implementations. Index only — тела в topic `.md`.
+Сетевой слой, persistence, DTO, mappers. Index only — тела в topic `.md`.
 
 | File | Cursor SoT |
 |------|------------|
 | [`networking.md`](./networking.md) | `networking-services.mdc` |
+| [`persistence.md`](./persistence.md) | `persistence-data.mdc` |
 
 Sync: change Cursor → update Claude twin same PR. Full map: [`../README.md`](../README.md).

package/presets/claude/ios-swift/rules/api-and-data/networking.md

@@ -9,8 +9,8 @@ paths:
 - Инкапсулировать:
   - HTTP-запросы (`URLSession` или клиент проекта),
   - URL, headers, status codes,
-  - Codable DTO,
-  - persistence (Core Data, SwiftData, Keychain — по репо).
+  - Codable DTO (транспорт).
+- Локальное хранение / Keychain — **`persistence.md`**, не смешивать с HTTP-клиентом без фасада-репозитория.
 - Наружу (Domain, ViewModel через repository) отдавать **доменные типы**, не DTO.
 
 # Структура модулей

package/presets/claude/ios-swift/rules/api-and-data/persistence.md

@@ -0,0 +1,30 @@
+---
+description: Persistence — SwiftData / Core Data / файлы / Keychain (не HTTP)
+paths:
+  - "**/Persistence/**/*.swift"
+  - "**/Keychain/**/*.swift"
+  - "**/*Storage*.swift"
+  - "**/*Cache*.swift"
+  - "**/*SwiftData*.swift"
+---
+
+# Persistence (Data)
+
+Отделить от HTTP (`api-and-data/networking.md`): здесь локальное хранение и секреты на диске/Keychain.
+
+## Рамка
+
+- Выбор стека (**SwiftData / Core Data / UserDefaults / files**) — **как в репо**; не внедрять второй persistence-стек без задачи.
+- Public API — протоколы в Domain (`…Repository` / `…Store`); реализации в Data.
+- **Keychain** — только для credentials/токенов; не класть PII «для удобства» в UserDefaults.
+
+## Правила
+
+- DTO/Entity persistence ≠ network DTO; маппинг явный.
+- Миграции схемы — по принятому в репо процессу; не ломать silently.
+- `@MainActor` на store — только если UI-facing; тяжёлый I/O — off-main + hop обратно.
+- Ошибки — typed; не глотать `try?` на критичном persist.
+
+## Требование к агенту
+
+Не смешивать URLSession и persistence в одном типе без фасада-репозитория. Тесты — in-memory / fake store.

package/presets/claude/ios-swift/rules/architecture/README.md

@@ -1,10 +1,12 @@
 # Architecture
 
-Границы слоёв Presentation / Domain / Data, DI, доставка фичи. Index only — тела в topic `.md`.
+Границы слоёв, DI, доставка фичи, SPM public API. Index only — тела в topic `.md`.
 
 | File | Cursor SoT |
 |------|------------|
 | [`boundaries.md`](./boundaries.md) | `architecture-boundaries.mdc` |
 | [`feature-delivery.md`](./feature-delivery.md) | `feature-delivery-workflow.mdc` |
+| [`reference-features.md`](./reference-features.md) | `reference-features.mdc` |
+| [`module-public-api.md`](./module-public-api.md) | `module-public-api.mdc` |
 
 Sync: change Cursor → update Claude twin same PR. Full map: [`../README.md`](../README.md).

package/presets/claude/ios-swift/rules/architecture/feature-delivery.md

@@ -1,5 +1,13 @@
 ---
 description: Сквозной чеклист доставки iOS-фичи и матрица «зона → правило». Use when implementing features, adding screens/API, or extending existing iOS flows.
+paths:
+  - .claude/commands/**/*
+  - .claude/team/**/*
+  - .claude/agents/**/*
+  - Features/**/*
+  - **/Presentation/**/*
+  - **/Domain/**/*
+  - **/Data/**/*
 ---
 
 # Доставка фичи (iOS)
@@ -13,7 +21,7 @@ description: Сквозной чеклист доставки iOS-фичи и м
 3. **ViewModel** — состояние, вызовы use case / протоколов; DI из App; без DTO и URL (`ui-and-accessibility/viewmodels.md`).
 4. **View / navigation** — тонкие SwiftUI Views, Design System; навигация как в репо (`ui-and-accessibility/swiftui.md`).
 5. **Тесты** — unit на mappers / use cases / VM (`testing/unit.md`); UI-потоки — XCUITest (`testing/ui.md`).
-6. **Завершение** — **`tooling-and-review/post-change-build.md`**: сборка затронутых таргетов + lint/format по конфигу репо.
+6. **Завершение** — **вызвать** `tooling-and-review/post-change-build.md` (+ `tooling-and-review/xcode-tooling.md`): сборка затронутых таргетов + lint/format по конфигу репо.
 
 ## Поток данных (ориентир)
 
@@ -55,6 +63,6 @@ flowchart LR
 | `**/*.swift` (стиль) | `stack/swift-conventions.md` |
 | `*Tests/**` | `testing/unit.md` |
 | `*UITests/**` | `testing/ui.md` |
-| После правок Swift | `tooling-and-review/post-change-build.md` |
+| После правок Swift | `tooling-and-review/post-change-build.md` (+ `tooling-and-review/xcode-tooling.md`) |
 
 При добавлении или расширении фичи **пройти чеклист** и правила из таблицы для затронутых зон.

package/presets/claude/ios-swift/rules/architecture/module-public-api.md

@@ -0,0 +1,25 @@
+---
+description: SPM / модули — public API, access control, запрет deep-import internals
+paths:
+  - "**/Package.swift"
+  - "**/*Public*.swift"
+  - "**/Sources/**/*.swift"
+---
+
+# Module public API (SPM)
+
+## Рамка
+
+- Потребители модуля импортируют **только public/open** API; `internal`/`fileprivate` — для реализации.
+- Deep-import чужих internal файлов — повод вынести символ в public API или рефакторить границы.
+
+## Правила
+
+- Новый публичный тип/функция — явный `public` + документация/пример использования при необходимости.
+- Barrel-стиль: один входной модуль / umbrella, если так заведено в репо.
+- Не экспортировать DTO сети из Presentation-facing модулей.
+- Версионирование breaking API — осознанно (SemVer пакета / release notes).
+
+## Требование к агенту
+
+Перед `public` на тип — проверить, нужен ли он снаружи. Следовать access control соседних модулей.