@1aboveio/skills 0.10.0

package/skills/engineering/resolve-issues/scripts/detect-target-branch.mjs

@@ -0,0 +1,256 @@
+// detect-target-branch — the MECHANIZED pre-flight step 3. It fetches, reads the
+// remote's real long-lived heads, and recommends the branch that holds the current
+// development head (or reports a conflict for the human to resolve). Pure git; no
+// network beyond the initial fetch.
+//
+// Why this exists as a script and not prose: pre-flight step 3 is a load-bearing
+// decision every later spawn rests on (implementers fork from it, the epic
+// integration gate forks its integration branch off it). Described as prose the
+// agent runs by hand, the GitFlow-vs-trunk content check degrades to a
+// commit-count guess — the exact mistake ("both sides are ahead, so it's a
+// conflict") the `git cherry` content check exists to avoid. Mechanized, the rule
+// runs the same way every time and shows its evidence.
+//
+//   node detect-target-branch.mjs            # fetch, detect, recommend (JSON on stdout)
+//   node detect-target-branch.mjs --no-fetch # skip the fetch (tests / already-fresh)
+//   node detect-target-branch.mjs --help     # usage + exit 0
+//
+// OUTPUT (stdout, always JSON):
+//   { recommended: <branch>|null, reason, candidates: [{name, ahead, behind, lastCommitDate}], conflict: bool }
+// The human still confirms in the pre-flight gate — this recommends and shows the
+// evidence, it does not decide silently.
+//
+// EXIT CODES:
+//   0  a recommendation was produced (recommended set, conflict false)
+//   1  genuine conflict / needs a human choice (recommended null, conflict true)
+//   2  usage error, or no long-lived branches found to compare
+//
+// The decision follows pre-flight.md step 3 exactly:
+//   - GitFlow  → dev (it contains main's tip and holds the development head)
+//   - trunk    → main (no long-lived dev branch)
+//   - nominal divergence (main holds promotion-merge commits dev lacks) is NOT a
+//     conflict: check CONTENT, not commit counts, with `git cherry` — if main has
+//     no non-merge commit dev lacks, dev still holds the development head.
+//   - genuine conflict (unique non-merge commits on BOTH sides, or dev behind main,
+//     or two plausible long-lived branches of the same family) → never pick; emit
+//     the candidates + evidence for the human to choose.
+
+import { execFileSync } from 'node:child_process'
+import { isMainModule } from '../../engineering-runtime/scripts/main-module.mjs'
+
+// The long-lived branch names we look for on the remote, in family-precedence order:
+// dev-family (the development line) and main-family (production). We compare the
+// real heads that exist, never convention or the local checkout.
+const DEV_FAMILY = ['dev', 'develop']
+const MAIN_FAMILY = ['main', 'master']
+
+// ---- pure, unit-testable core (no git, no network) ----
+
+// Count the `+` lines in `git cherry` output — commits present on the head branch
+// that are NOT in upstream and have no equivalent patch upstream (a `-` line means
+// an equivalent commit already exists upstream; merge commits are skipped entirely).
+// This is the CONTENT check: `+` count > 0 means genuinely unique non-merge content.
+export function countCherryUnique(cherryOutput) {
+  if (!cherryOutput) return 0
+  return cherryOutput
+    .split('\n')
+    .filter((l) => l.trim().startsWith('+'))
+    .length
+}
+
+// The whole decision, as a pure function of gathered facts so it is testable
+// without a git repo. `facts`:
+//   devFamily, mainFamily : existing branch names of each family (subset of the
+//                           family lists above, in precedence order)
+//   candidates            : [{name, ahead, behind, lastCommitDate}] evidence for
+//                           every existing long-lived branch (ahead/behind measured
+//                           against the reference — the main-family primary)
+//   mainUnique, devUnique : `git cherry` `+` counts for the dev-vs-main pair
+//                           (main-not-in-dev, dev-not-in-main); null when there is
+//                           not exactly one dev and one main to compare
+// Returns { recommended, reason, candidates, conflict }.
+export function decideTargetBranch({ devFamily, mainFamily, candidates, mainUnique, devUnique }) {
+  const conflict = (reason) => ({ recommended: null, reason, candidates, conflict: true })
+  const recommend = (name, reason) => ({ recommended: name, reason, candidates, conflict: false })
+
+  // Two plausible long-lived branches of the same family both exist (e.g. dev AND
+  // develop, or main AND master) — a tie: we cannot say which is the long-lived
+  // line. Never pick; hand the candidates to the human.
+  if (devFamily.length > 1) {
+    return conflict(`two long-lived development branches exist (${devFamily.join(', ')}) — ambiguous which is the development line; choose one`)
+  }
+  if (mainFamily.length > 1) {
+    return conflict(`two long-lived production branches exist (${mainFamily.join(', ')}) — ambiguous which is production; choose one`)
+  }
+
+  const dev = devFamily[0]
+  const main = mainFamily[0]
+
+  // Trunk-based: no long-lived dev branch → main holds the development head.
+  if (!dev && main) {
+    return recommend(main, `trunk-based: ${main} is the only long-lived branch, so it holds the development head`)
+  }
+  // Only a dev-family branch exists (no main/master at all) — unusual, but the sole
+  // long-lived branch is the development head by default.
+  if (dev && !main) {
+    return recommend(dev, `${dev} is the only long-lived branch, so it holds the development head`)
+  }
+
+  // Exactly one dev and one main: the GitFlow-vs-trunk content decision.
+  // `mainUnique` is the count of non-merge commits main has that dev lacks. Zero
+  // means main has no CONTENT dev lacks — dev still holds the development head,
+  // whether main is a strict ancestor (classic GitFlow) or diverged only by
+  // promotion-merge commits (nominal divergence). Recommend dev.
+  if (mainUnique === 0) {
+    const devEvidence = candidates.find((c) => c.name === dev)
+    const kind = devEvidence && devEvidence.behind === 0
+      ? `${main} is an ancestor of ${dev}`
+      : `${main}'s extra commits carry no content ${dev} lacks (git cherry: no unique non-merge commits)`
+    return recommend(dev, `${dev} holds the development head — ${kind}`)
+  }
+
+  // main has genuine non-merge content dev lacks. If dev has none of its own, dev
+  // sits BEHIND main — a conflict the human must resolve (do not silently promote
+  // main). If both sides carry unique content, they have genuinely diverged.
+  if (devUnique === 0) {
+    return conflict(`${dev} sits behind ${main}: ${main} has ${mainUnique} unique non-merge commit(s) ${dev} lacks and ${dev} has none of its own — choose the target`)
+  }
+  return conflict(`${dev} and ${main} have diverged: unique non-merge commits on both sides (${dev}: ${devUnique}, ${main}: ${mainUnique}) — choose the target`)
+}
+
+// ---- git live facts (side-effecting; not unit-tested, like combine-and-verify's) ----
+
+function git(args, opts = {}) {
+  return execFileSync('git', args, { encoding: 'utf8', ...opts }).trim()
+}
+
+// Does origin/<name> resolve to a commit? Fails closed (false) on any error so a
+// missing remote-tracking ref simply means "that candidate does not exist".
+function remoteRefExists(name) {
+  try {
+    execFileSync('git', ['rev-parse', '--verify', '--quiet', `origin/${name}^{commit}`], { stdio: 'ignore' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+// ahead/behind of `name` relative to `ref`, both remote heads. `git rev-list
+// --left-right --count origin/ref...origin/name` prints "<left>\t<right>" where
+// left = commits reachable from ref not name, right = commits reachable from name
+// not ref. So ahead (name has, ref lacks) = right; behind (ref has, name lacks) = left.
+function aheadBehind(ref, name) {
+  if (ref === name) return { ahead: 0, behind: 0 }
+  const out = git(['rev-list', '--left-right', '--count', `origin/${ref}...origin/${name}`])
+  const [left, right] = out.split(/\s+/).map((n) => parseInt(n, 10))
+  return { ahead: right || 0, behind: left || 0 }
+}
+
+// Committer date (ISO 8601) of the tip of origin/<name>.
+function lastCommitDate(name) {
+  try {
+    return git(['log', '-1', '--format=%cI', `origin/${name}`])
+  } catch {
+    return null
+  }
+}
+
+// `+`-count of `git cherry <upstream> <head>` — non-merge commits on head not in
+// upstream and without an equivalent patch there. See countCherryUnique.
+function cherryUnique(upstream, head) {
+  let out = ''
+  try {
+    out = git(['cherry', `origin/${upstream}`, `origin/${head}`])
+  } catch {
+    return 0
+  }
+  return countCherryUnique(out)
+}
+
+// Gather every fact decideTargetBranch needs from the live remote heads.
+export function gatherFacts() {
+  const existing = [...DEV_FAMILY, ...MAIN_FAMILY].filter(remoteRefExists)
+  const devFamily = existing.filter((n) => DEV_FAMILY.includes(n))
+  const mainFamily = existing.filter((n) => MAIN_FAMILY.includes(n))
+
+  // Reference for the ahead/behind evidence: the production primary when present,
+  // else the development primary — so every candidate's counts are read against a
+  // single, interpretable baseline (for the standard one-dev/one-main repo this is
+  // exactly dev-vs-main).
+  const reference = mainFamily[0] || devFamily[0] || existing[0]
+  const candidates = existing.map((name) => ({
+    name,
+    ...aheadBehind(reference, name),
+    lastCommitDate: lastCommitDate(name),
+  }))
+
+  // The content check only applies when there is exactly one dev and one main to
+  // compare; otherwise the family-tie / trunk / dev-only branches decide it.
+  let mainUnique = null
+  let devUnique = null
+  if (devFamily.length === 1 && mainFamily.length === 1) {
+    mainUnique = cherryUnique(devFamily[0], mainFamily[0]) // main commits not in dev
+    devUnique = cherryUnique(mainFamily[0], devFamily[0]) // dev commits not in main
+  }
+
+  return { devFamily, mainFamily, candidates, mainUnique, devUnique }
+}
+
+// ---- CLI ----
+
+const USAGE = `detect-target-branch — recommend the source/base branch from the remote's long-lived heads.
+Usage:
+  detect-target-branch [--no-fetch]
+Options:
+  --no-fetch   skip \`git fetch origin\` (for tests, or when the remote is already fresh)
+  --help, -h   show this help and exit 0
+Output: JSON on stdout — { recommended, reason, candidates: [{name, ahead, behind, lastCommitDate}], conflict }.
+Exit codes: 0 = recommendation produced, 1 = genuine conflict (human chooses), 2 = usage error / no long-lived branches.
+The human confirms the recommendation in the pre-flight gate; this recommends + shows evidence, it does not decide silently.`
+
+function parseArgs(argv) {
+  const f = {}
+  for (const a of argv) {
+    if (a === '--help' || a === '-h' || a === 'help') f.help = true
+    else if (a === '--no-fetch') f.noFetch = true
+    else f.unknown = a
+  }
+  return f
+}
+
+export function runCli(argv) {
+  const f = parseArgs(argv)
+  if (f.help) {
+    console.log(USAGE)
+    return 0
+  }
+  if (f.unknown) {
+    console.error(`detect-target-branch: unknown argument "${f.unknown}"\n${USAGE}`)
+    return 2
+  }
+
+  if (!f.noFetch) {
+    try {
+      execFileSync('git', ['fetch', 'origin'], { stdio: 'ignore' })
+    } catch {
+      console.error('  ⚠ git fetch origin failed; detecting against the last-known remote heads')
+    }
+  }
+
+  const facts = gatherFacts()
+  if (facts.devFamily.length === 0 && facts.mainFamily.length === 0) {
+    console.error('detect-target-branch: no long-lived branches (origin/{dev,develop,main,master}) found — is this a fresh remote?')
+    return 2
+  }
+
+  const result = decideTargetBranch(facts)
+  console.log(JSON.stringify(result, null, 2))
+  // A one-line human cue on stderr so someone running it by hand sees the verdict.
+  if (result.conflict) console.error(`detect-target-branch: ⚠ conflict — ${result.reason}`)
+  else console.error(`detect-target-branch: ✓ recommend ${result.recommended} — confirm in the pre-flight gate`)
+  return result.conflict ? 1 : 0
+}
+
+if (isMainModule(import.meta.url)) {
+  process.exit(runCli(process.argv.slice(2)))
+}

package/skills/engineering/resolve-issues/scripts/detect-workspace-mode.mjs

@@ -0,0 +1,168 @@
+// detect-workspace-mode — where the run's code-writing happens: the human's checkout, or
+// a worktree of its own.
+//
+// This is a SETTING WITH A PROBED DEFAULT, deliberately not another pre-flight question.
+// The neutral batch already carries implementer · reviewer when required · branch ·
+// autonomy, and another question can overflow the selected adapter's one-call capacity.
+// It is also the wrong thing to ask: the
+// answer turns on facts about the tree (is it dirty, are we already isolated) that the
+// human usually cannot recall at the prompt, and that a probe reads exactly. Same reasoning
+// as deliveryMode, and the same shape as breakerAutonomy — a default the human can override
+// by naming it, surfaced in the pre-flight summary so a wrong guess is correctable before
+// any work runs.
+//
+//   node detect-workspace-mode.mjs                # probe the cwd, recommend (JSON on stdout)
+//   node detect-workspace-mode.mjs --repo-dir DIR # probe a specific checkout
+//   node detect-workspace-mode.mjs --help
+//
+// OUTPUT (stdout, always JSON):
+//   { mode: "shared"|"worktree"|null, reason, signals: {dirty, insideWorktree, gitDir}, probed }
+//
+// EXIT CODES:
+//   0  a mode was determined
+//   2  UNDETERMINED (not a git repo, or git unreadable) or usage error — never a silent default.
+//
+// The trade this encodes, and why `worktree` is NOT the blanket default: a fresh worktree
+// has no `node_modules`, no `.env`, no build cache. On a product repo that means an install
+// before the first test can run, which is a real cost paid on every run. So `shared` stays
+// the default for a clean tree, and `worktree` is reserved for the case where sharing is
+// actively unsafe — plus any run where the human asks for it.
+
+import { execFileSync } from 'node:child_process'
+import { realpathSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+export const WORKSPACE_MODES = ['shared', 'worktree']
+
+// ---- pure, unit-testable core ----
+
+// The one case where `shared` is not a preference but a hazard: a dirty tree. The current
+// rule stops the run and asks the human to commit or stash (never stashing for them),
+// because a branch switch can fail on uncommitted changes or silently carry them into a
+// unit's diff. A worktree dissolves that dilemma — the run gets a clean tree of its own and
+// the human's work is never touched — so the dirty case recommends `worktree` rather than
+// stopping. That is a strictly better answer than the stop it replaces.
+export function decideWorkspaceMode({ isRepo, dirty, insideWorktree, disposable = false } = {}) {
+  if (!isRepo) {
+    return { mode: null, probed: false, reason: 'not a git repository (or git was unreadable) — the workspace mode is UNKNOWN; settle it before any spawn writes code' }
+  }
+  // Already isolated. Nesting a worktree inside a worktree, or inside a throwaway CI clone,
+  // buys nothing and costs a second dependency install.
+  if (insideWorktree || disposable) {
+    return { mode: 'shared', probed: true, reason: `already an isolated checkout (${insideWorktree ? 'a linked git worktree' : 'a disposable clone'}) — the run has nothing to gain from another one, and its branch switches touch no working tree the human is using` }
+  }
+  if (dirty) {
+    return { mode: 'worktree', probed: true, reason: 'the working tree has uncommitted changes — running here would switch branches under them, which can fail or silently carry them into a unit diff. A worktree leaves the human\'s tree untouched, so this replaces the dirty-tree stop rather than blocking the run' }
+  }
+  return { mode: 'shared', probed: true, reason: 'the working tree is clean, so branch switches are safe here — and a fresh worktree would owe a dependency install before the first test could run. Ask for `worktree` explicitly to keep the checkout free while the run works' }
+}
+
+// ---- impure probe ----
+
+function git(args, cwd) {
+  try { return { ok: true, out: execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() } }
+  catch (error) { return { ok: false, out: '', error } }
+}
+
+export function gatherWorkspaceSignals(cwd) {
+  const top = git(['rev-parse', '--show-toplevel'], cwd)
+  if (!top.ok) return { isRepo: false, dirty: false, insideWorktree: false, gitDir: null, toplevel: null }
+  // `--untracked-files=no` deliberately. The hazard this check exists for is a branch
+  // switch failing on, or silently carrying, *tracked* modifications. Untracked files are
+  // carried across a switch harmlessly — and counting them made this probe recommend
+  // `worktree` for essentially every real checkout, since almost all of them carry a
+  // stray `.env`, a log, or an editor file. That inverted the documented default (clean
+  // tree → shared) and would have imposed a dependency install on every run.
+  //
+  // The residual case is narrow and git handles it loudly: an untracked file whose path
+  // the target branch also contains makes checkout refuse with a clear error, rather than
+  // corrupting anything. A loud stop on a rare collision is a better trade than a silent
+  // default flip on the common path.
+  const status = git(['status', '--porcelain', '--untracked-files=no'], cwd)
+  // A LINKED worktree's `.git` is a file pointing at the parent's admin dir, so
+  // --git-common-dir and --git-dir differ. In the primary checkout they are the same.
+  const gitDir = git(['rev-parse', '--absolute-git-dir'], cwd)
+  const commonDir = git(['rev-parse', '--path-format=absolute', '--git-common-dir'], cwd)
+  const insideWorktree = gitDir.ok && commonDir.ok && gitDir.out !== commonDir.out
+  return {
+    isRepo: true,
+    // An unreadable status is NOT "clean" — that would be the fabricated-evidence failure
+    // the delivery probe exists to avoid. Treat it as dirty: the conservative direction.
+    dirty: !status.ok || status.out.length > 0,
+    insideWorktree,
+    gitDir: gitDir.ok ? gitDir.out : null,
+    toplevel: top.out,
+  }
+}
+
+// The path a `worktree`-mode run should use. Kept beside the repo rather than inside it so
+// it never lands in `git status`, never collides with the run's own branch switches, and is
+// obvious to a human cleaning up by hand.
+export function worktreePathFor(toplevel, slug) {
+  const base = String(toplevel || '').replace(/\/+$/, '')
+  const name = String(slug || 'run').replace(/[^\w.-]+/g, '-')
+  return `${base}-worktrees/${name}`
+}
+
+function parseArgs(argv) {
+  const f = {}
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    if (a === '--repo-dir') f.repoDir = argv[++i]
+    else if (a === '--slug') f.slug = argv[++i]
+    else if (a === '--disposable') f.disposable = true
+    else if (a === '--help' || a === '-h') f.help = true
+  }
+  return f
+}
+
+export function runCli(argv) {
+  const f = parseArgs(argv)
+  if (f.help) {
+    console.log(`detect-workspace-mode [--repo-dir <dir>] [--slug <run-slug>] [--disposable]
+Recommends workspaceMode (shared|worktree) for a run's code-writing spawns.
+
+  shared    every spawn works in the current checkout (today's behavior)
+  worktree  the run gets a checkout of its own; the human's tree is never touched
+
+Probed, not asked: pre-flight already has a complete adapter-planned question batch,
+and the answer turns on tree state the human cannot recall at a prompt. A dirty tree
+recommends worktree — which
+replaces the dirty-tree stop rather than blocking the run. Override by naming it.
+exit 0 = mode determined · 2 = UNDETERMINED (not a git repo) or usage error.`)
+    return 0
+  }
+  const cwd = f.repoDir || process.cwd()
+  const signals = gatherWorkspaceSignals(cwd)
+  const decision = decideWorkspaceMode({ ...signals, disposable: f.disposable })
+  const out = { ...decision, signals }
+  if (decision.mode === 'worktree' && signals.toplevel) {
+    out.worktreePath = worktreePathFor(signals.toplevel, f.slug || 'run')
+    out.setup = `git worktree add ${out.worktreePath} <targetBranch>`
+    out.teardown = `git worktree remove ${out.worktreePath}`
+  }
+  console.log(JSON.stringify(out, null, 2))
+  return decision.mode ? 0 : 2
+}
+
+let launchedDirectly = false
+let mainModuleError = null
+try {
+  const { isMainModule } = await import('../../engineering-runtime/scripts/main-module.mjs')
+  if (typeof isMainModule !== 'function') throw new Error('main-module.mjs does not export isMainModule')
+  launchedDirectly = isMainModule(import.meta.url)
+} catch (error) {
+  mainModuleError = error
+  try {
+    launchedDirectly = realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))
+  } catch {
+    launchedDirectly = false
+  }
+}
+
+if (launchedDirectly && mainModuleError) {
+  console.error(`detect-workspace-mode: cannot load engineering-runtime main-module helper: ${mainModuleError.message}`)
+  process.exitCode = 1
+} else if (launchedDirectly) {
+  process.exit(runCli(process.argv.slice(2)))
+}

package/skills/engineering/resolve-issues/scripts/discover-models.mjs

@@ -0,0 +1,9 @@
+// Compatibility wrapper: canonical ownership lives in harness-runtime.
+export * from '../../harness-runtime/discover-models.mjs'
+
+import { runCli } from '../../harness-runtime/discover-models.mjs'
+import { isMainModule } from '../../engineering-runtime/scripts/main-module.mjs'
+
+if (isMainModule(import.meta.url)) {
+  process.exit(runCli(process.argv.slice(2)))
+}

package/skills/engineering/resolve-issues/scripts/doctrine.mjs

@@ -0,0 +1,62 @@
+// The resolve-issues doctrine as ONE document, however it happens to be split across files.
+//
+// Why this exists: SKILL.md used to hold the whole loop — 226 lines, but 57KB, the densest file
+// in this repo at ~250 bytes a line. Several tests here assert that a rule is *stated*, and they
+// did that by reading SKILL.md directly. That premise broke when the doctrine moved into
+// `references/`, and it broke for a reason worth keeping written down: an agent harness loaded
+// the sibling `resolve-release/SKILL.md` as lines 1-260 of 491 and silently dropped its
+// traffic-shift and rollback steps. A skill does not fail when it is truncated; it quietly
+// becomes a shorter, different skill. The defence is an index small enough that no plausible
+// budget reaches its end, with the phases in files an agent fetches deliberately.
+//
+// These tests grade the *doctrine* — that a rule exists, that its incident is cited, that a
+// default is stated with its escape hatch. None of that is a claim about which file the sentence
+// lives in, so the doctrine is reassembled here in its original document order and the tests read
+// it from this module instead of from a path.
+//
+// The reassembly is faithful rather than approximate: each phase file was extracted as a
+// contiguous line range, in order, so concatenating them in that order reproduces the original.
+// Each reference opens with a NEW `# Title` and orientation paragraph that did not exist before;
+// those are stripped, resuming at the first heading that came from the original document — which
+// is why each entry below names it.
+//
+// SKILL.md is included whole. Unlike resolve-release, it kept no duplicate heading of a moved
+// section (its pre-flight section was always just a pointer at references/pre-flight.md), so
+// there is no shadowing heading to exclude.
+//
+// If a future split moves a section again, update ORDER in the same commit. A test that fails
+// because prose moved is this module being stale, not doctrine being lost — but confirm which
+// before editing anything here.
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const skillDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const read = (rel) => fs.readFileSync(path.join(skillDir, rel), 'utf8')
+
+const ORDER = [
+  // The four guarantees keep their bars on SKILL.md; their detail moved here (2026-08-16).
+  { file: 'references/guarantees.md', resumeAt: '## The four guarantees' },
+  { file: 'references/intake.md', resumeAt: '## Intake & scheduling' },
+  { file: 'references/loop.md', resumeAt: '## The loop (per unit)' },
+  { file: 'references/deliverables.md', resumeAt: '## Deliverables:' },
+]
+
+function bodyFrom({ file, resumeAt }) {
+  const text = read(file)
+  const idx = text.indexOf(`\n${resumeAt}`)
+  if (idx < 0) {
+    throw new Error(
+      `doctrine.mjs: ${file} no longer contains "${resumeAt}". Either the heading was reworded ` +
+      '(update ORDER here, same commit) or the section moved again (update ORDER, and check the ' +
+      'section still exists somewhere before assuming it is only a rename).',
+    )
+  }
+  return text.slice(idx + 1)
+}
+
+export function loadDoctrine() {
+  return [read('SKILL.md'), ...ORDER.map(bodyFrom)].join('\n')
+}
+
+export const DOCTRINE = loadDoctrine()