Feature/architectural conventions standard (#243)

* feat(conventions): standard schema models + effective-map merge

* feat(conventions): tree-sitter Python classifier + placement checks

* feat(conventions): TS classifier, hygiene/custom checks, runner + CLI

* feat(conventions): ROBOCO_CONVENTIONS_ENABLED flag + cache table + migration

* feat(conventions): repo auto-scan + scaffold draft renderer

* feat(conventions): ConventionsService (cache/baseline/ambient/scaffold/restore)

* feat(conventions): auto-scaffold on project registration (flag-gated)

* feat(conventions): TaskDescription.constraints + auto-baseline attach

* feat(conventions): ambient architecture-map injection at spawn

* test(conventions): subprocess CLI smoke for the agent-image entrypoint

* feat(conventions): block i_am_done on block-level convention violations

* feat(conventions): block pr_pass on unresolved convention violations

* feat(conventions): surface convention findings into QA evidence

* docs(prompts): convention awareness for PO/Intake/Dev/QA/PR-reviewer

* feat(conventions): panel Conventions tab + flag toggle + parity

* test(conventions): end-to-end block, fix, and waiver through the gate

* refactor(conventions): extract pr_pass guards to keep pr_gate under the gate

* style(conventions): format the baseline-constraints attach in task.create

* test(conventions): type-annotate test helpers for the full mypy gate

* build(conventions): ignore types-PyYAML in deptry (mypy-only type stub)

* docs(conventions): document the standard in CLAUDE.md + PM prompt awareness

* fix(conventions): baseline constraints are non-suppressible (dedup-append)

* feat(conventions): scaffold on first workspace clone (threaded workspace)

* feat(conventions): multi-project ambient map for PO/Intake (per-product)

* feat(conventions): persist findings + violations-feed route (migration 044)

* feat(conventions): panel violations feed in the Conventions tab

* test(conventions): intake-spawn mock accepts the ambient layer kwarg

* fix(docker): ollama-init best-effort pull, gate startup on cached models present

A degraded/slow ollama registry made the model manifest re-check fail under
set -e, so ollama-init exited 1 and blocked the orchestrator's
service_completed_successfully gate — taking the whole stack down even though
both models were already cached. Pulls are now best-effort; success is gated on
the models being present, so a flaky registry can't down a cached deployment.

* refactor(content): drop dead TaskDescription.with_baseline_constraints

The structured baseline-merge helper had zero production callers. Project-task baseline constraints are attached by the wired string backstop (TaskService._attach_baseline_constraints), and a real task is free-form prose that cannot form a valid TaskDescription (requires a non-trivial objective + non-empty the_work), so the helper was unreachable from any live path — a leftover from the structured-merge -> string-append design pivot. Removing it leaves a single enforcement path. The constraints field itself stays: it is a member of the well-formed-spec schema (Objective / What This Builds / The Work / Notes / Constraints / Acceptance Criteria), rendered by render_markdown and unit-tested.

---------

Co-authored-by: Renn F <rennf93@users.noreply.github.com>

panel/src/lib/api/conventions.ts

@@ -0,0 +1,110 @@
+import api from "./client";
+
+// Mirrors roboco.foundation.policy.conventions.models — kept in sync by the
+// TS<->Python parity test (tests/unit/foundation/policy/conventions/test_ts_parity.py).
+export type RuleLevel = "warn" | "block";
+export type DefinitionKind =
+  | "model"
+  | "route"
+  | "helper"
+  | "business_logic"
+  | "component"
+  | "other";
+
+export interface ConventionsModule {
+  path: string;
+  purpose: string;
+  forbidden: DefinitionKind[];
+}
+
+export interface ConventionsRule {
+  name: string;
+  level: RuleLevel;
+}
+
+export interface ConventionsCustomRule {
+  id: string;
+  pattern: string;
+  message: string;
+  level: RuleLevel;
+  languages: string[];
+}
+
+export interface ConventionsWaiver {
+  path: string;
+  rule: string;
+  reason: string;
+}
+
+export interface ConventionsStandard {
+  version: number;
+  languages: string[];
+  modules: ConventionsModule[];
+  rules: Record<string, ConventionsRule>;
+  custom: ConventionsCustomRule[];
+  waivers: ConventionsWaiver[];
+}
+
+export interface ConventionsHealth {
+  status: string;
+  head_sha: string;
+  last_ok_sha: string | null;
+}
+
+export interface ConventionsResponse {
+  standard: ConventionsStandard;
+  health: ConventionsHealth;
+}
+
+export interface ConventionsActionResult {
+  pr_number: number | null;
+  branch: string;
+  created: boolean;
+}
+
+export interface ConventionFinding {
+  file: string;
+  line: number;
+  rule: string;
+  level: RuleLevel;
+  kind: string | null;
+  message: string;
+  task_id: string | null;
+  detected_at: string;
+}
+
+export const conventionsApi = {
+  // GET the project's effective map + health.
+  get: async (projectId: string): Promise<ConventionsResponse> => {
+    const { data } = await api.get<ConventionsResponse>(
+      `/projects/${projectId}/conventions`,
+    );
+    return data;
+  },
+  // PUT an edited standard — opens a PR committing it back (PM+).
+  update: async (
+    projectId: string,
+    standard: ConventionsStandard,
+  ): Promise<ConventionsActionResult> => {
+    const { data } = await api.put<ConventionsActionResult>(
+      `/projects/${projectId}/conventions`,
+      standard,
+    );
+    return data;
+  },
+  // POST restore — re-commits the file from the last-good map (PM+).
+  restore: async (projectId: string): Promise<ConventionsActionResult> => {
+    const { data } = await api.post<ConventionsActionResult>(
+      `/projects/${projectId}/conventions/restore`,
+      {},
+    );
+    return data;
+  },
+  // GET the recent violations feed for the project.
+  findings: async (projectId: string): Promise<ConventionFinding[]> => {
+    const { data } = await api.get<ConventionFinding[]>(
+      `/projects/${projectId}/conventions/findings`,
+    );
+    return data;
+  },
+};