mandrel 1.73.0 → 1.74.0

package/.agents/README.md

@@ -33,7 +33,7 @@ It then shows a **two-option prompt**:
 
 1. **Configure now** — runs `node .agents/scripts/bootstrap.js`, forwarding any
    passthrough flags unchanged, to wire the project and GitHub side (creates the
-   GitHub repo + Projects board).
+   GitHub repo; board decoration and Issue Forms are opt-in — see below).
 2. **Just the files** — stops after materialization and prints a re-run hint
    (`mandrel init`) so you can configure later.
 
@@ -100,9 +100,13 @@ The bootstrap pipeline, in order:
    `.claude/commands/` tree so every `/<command>` loads), wires the system
    prompt (see below), gitignores derived artefacts, and runs the
    quality-gates installer.
-4. **GitHub-side mutations.** Creates the label taxonomy, Project V2
-   fields, branch protection, and merge-method settings. Skipped with
-   `--skip-github`.
+4. **GitHub-side mutations.** Creates the label taxonomy, branch protection,
+   and merge-method settings. Skipped with `--skip-github`. Two additional
+   mutations are **opt-in** (prompted y/N, defaulting No, or passed as flags):
+   - `--with-project-board` — provision the Projects V2 Status field and
+     custom fields on an existing board.
+   - `--with-issue-forms` — generate `.github/ISSUE_TEMPLATE/story.yml` and
+     `epic.yml` from the ticket-body schema.
 
 The bootstrap is idempotent — safe to re-run; an already-configured
 clone produces zero file mutations.
@@ -184,7 +188,7 @@ Reverses a recorded install using the install ledger
 (`.agents/.install-manifest.json`). Each ledger entry is a
 mutation-manifest record; uninstall walks reversible entries and undoes
 exactly what the install applied, without touching pre-existing operator
-content. GitHub-side state (labels, branch protection, Projects board)
+content. GitHub-side state (labels, branch protection, project board fields)
 requires manual reversal and is surfaced as a follow-up checklist.
 
 ```bash

package/.agents/scripts/agents-bootstrap-github.js

@@ -43,7 +43,6 @@ import { Logger } from './lib/Logger.js';
 import {
   LABEL_TAXONOMY,
   PROJECT_FIELD_DEFS,
-  PROJECT_VIEW_DEFS,
   STATUS_FIELD_OPTIONS,
 } from './lib/label-taxonomy.js';
 import { createProvider } from './lib/provider-factory.js';
@@ -154,25 +153,6 @@ async function ensureStatusField(provider, log) {
   }
 }
 
-async function ensureViews(provider, log) {
-  try {
-    const views = await provider.ensureProjectViews(PROJECT_VIEW_DEFS);
-    if (views.unavailable) {
-      log(
-        `[Bootstrap] Projects V2 Views unavailable — skipped ${views.skipped.join(', ')}.${views.error ? ` (${views.error})` : ''} ${PROJECTS_DOC_POINTER}`,
-      );
-    } else {
-      log(
-        `[Bootstrap] Views — created: ${views.created.length}, skipped: ${views.skipped.length}`,
-      );
-    }
-    return views;
-  } catch (err) {
-    log(`[Bootstrap] Views provisioning failed: ${err.message}`);
-    return { created: [], skipped: [], unavailable: false };
-  }
-}
-
 /**
  * Audit the project's built-in workflows and, when explicitly opted-in
  * via `--reap-conflicting-workflows`, delete the ones that race against
@@ -283,10 +263,15 @@ async function ensureProjectFields(provider, project, log) {
  *   github?: object,
  *   baseBranch?: string,
  *   githubAdminApproved?: boolean,
+ *   withProjectBoard?: boolean,
  *   isTTY?: boolean,
  * }} [opts] - `githubAdminApproved` MUST be `true` for any GitHub mutation to
  *   occur; any other value (absent / `false`) is treated as "not approved"
  *   and the run is a verified no-op.
+ *   `withProjectBoard` (default `false`) — opt-in for Projects V2 board,
+ *   Status field, custom fields, and workflow audit. When absent or `false`,
+ *   the board decoration is skipped and only labels + branch protection +
+ *   merge methods are provisioned.
  */
 export async function runBootstrap(config, opts = {}) {
   // Explicit opt-in gate (Story #3526). Default-deny: absent or non-`true`
@@ -316,36 +301,46 @@ export async function runBootstrap(config, opts = {}) {
   log('[Bootstrap] API access verified.');
 
   const labels = await ensureLabels(provider, log);
-  const project = await resolveProject(provider, providerConfig, log);
 
-  const projectReady = !project.skipped && project.projectNumber;
+  // Board decoration (Projects V2 board, Status field, custom fields, workflow
+  // audit) is opt-in and defaults OFF. Minimal install = labels only. Gate is
+  // `opts.withProjectBoard === true`; absent or false skips all board work.
+  // ColumnSync already soft-noops when projectNumber is unset (column-sync.js:19-23).
+  const projectBoard = opts.withProjectBoard === true;
+  let project = { projectNumber: null, created: false, skipped: true };
   let statusField = { status: 'skipped', added: [] };
-  let views = { created: [], skipped: [], unavailable: false };
   let fields = { created: [], skipped: [] };
+  let workflowAudit = {
+    skipped: true,
+    reason: 'board-decoration-not-opted-in',
+  };
 
-  if (projectReady) {
-    statusField = await ensureStatusField(provider, log);
-    views = await ensureViews(provider, log);
-    fields = await ensureProjectFields(provider, project, log);
-  } else {
-    log('[Bootstrap] No active project — skipping legacy project-field setup.');
-  }
-
-  // Story #2845 — audit project workflows for the ones that race against
-  // the orchestrator's ColumnSync writes (notably `Pull request merged`
-  // and `Pull request linked to issue`, which both rewrite Status as a
-  // side-effect of auto-merge). When `--reap-conflicting-workflows` is
-  // set, also delete the offenders via `deleteProjectV2Workflow` (the
-  // only programmatic action GraphQL exposes today — `enabled` is
-  // read-only).
-  const workflowAudit = projectReady
-    ? await auditAndOptionallyReapWorkflows(
+  if (projectBoard) {
+    project = await resolveProject(provider, providerConfig, log);
+    const projectReady = !project.skipped && project.projectNumber;
+    if (projectReady) {
+      statusField = await ensureStatusField(provider, log);
+      fields = await ensureProjectFields(provider, project, log);
+      // Story #2845 — audit project workflows for the ones that race against
+      // the orchestrator's ColumnSync writes (notably `Pull request merged`
+      // and `Pull request linked to issue`, which both rewrite Status as a
+      // side-effect of auto-merge). When `--reap-conflicting-workflows` is
+      // set, also delete the offenders via `deleteProjectV2Workflow` (the
+      // only programmatic action GraphQL exposes today — `enabled` is
+      // read-only).
+      workflowAudit = await auditAndOptionallyReapWorkflows(
         provider,
         project.projectNumber,
         opts.reapConflictingWorkflows === true,
         log,
-      )
-    : { skipped: true, reason: 'no-project' };
+      );
+    } else {
+      log('[Bootstrap] No active project — skipping project-field setup.');
+      workflowAudit = { skipped: true, reason: 'no-project' };
+    }
+  } else {
+    log('[Bootstrap] Project board decoration skipped (opt-in not set).');
+  }
 
   // Consumer-facing bootstrap promotes the framework's CI-gates-only
   // stance: branch protection with enforce_admins + 0-approval-count and
@@ -405,7 +400,6 @@ export async function runBootstrap(config, opts = {}) {
     fields,
     project,
     statusField,
-    views,
     workflowAudit,
     branchProtection,
     mergeMethods,
@@ -490,6 +484,10 @@ async function main() {
   // invocation never silently reconfigures branch protection or merge methods.
   const githubAdminApproved =
     assumeYes || process.argv.includes('--approve-github-admin');
+  // Story #4234 — Board decoration is opt-in (default off). Pass
+  // `--with-project-board` to also provision the Projects V2 board, Status
+  // field, and custom fields.
+  const withProjectBoard = process.argv.includes('--with-project-board');
 
   try {
     const result = await runBootstrap(config, {
@@ -499,6 +497,7 @@ async function main() {
       assumeNo,
       reapConflictingWorkflows,
       githubAdminApproved,
+      withProjectBoard,
     });
     // A non-approved run returns the skip envelope (no full result shape);
     // the skip line is already logged inside runBootstrap, so render the

package/.agents/scripts/bootstrap.js

@@ -37,8 +37,16 @@
  *                             (labels, Projects V2, branch protection, merge
  *                             methods) without accepting every other default.
  *   --skip-github             Skip the GitHub-side bootstrap entirely
- *   --skip-quality            Skip the quality-gates bootstrap
+ *   --with-quality            Opt-in: install local quality gates (pre-commit
+ *                             hook + quality:preview/watch scripts). Off by
+ *                             default — prompted y/N.
  *   --dry-run                 Collect info and print the plan; change nothing
+ *   --with-project-board      Opt-in: provision the Projects V2 Status field
+ *                             and custom fields. Off by default — the project
+ *                             board object is still created when a project
+ *                             name is supplied, but decoration is skipped.
+ *   --with-issue-forms        Opt-in: generate .github/ISSUE_TEMPLATE/story.yml
+ *                             and epic.yml. Off by default.
  *   --reap-conflicting-workflows  Delete Projects V2 built-in workflows that
  *                             race against the orchestrator (destructive)
  *   --help                    Print this help
@@ -97,8 +105,14 @@ Flags:
                             (labels, Projects V2, branch protection, merge
                             methods) without accepting every other default.
   --skip-github             Skip the GitHub-side bootstrap entirely
-  --skip-quality            Skip the quality-gates bootstrap
+  --with-quality            Opt-in: install local quality gates (pre-commit
+                            hook + quality:preview/watch scripts).
+                            (default: off — prompted y/N).
   --dry-run                 Collect info and print the plan; change nothing
+  --with-project-board      Opt-in: provision the Projects V2 Status field
+                            and custom fields (default: off — prompted y/N).
+  --with-issue-forms        Opt-in: generate .github/ISSUE_TEMPLATE/story.yml
+                            and epic.yml (default: off — prompted y/N).
   --reap-conflicting-workflows  Delete Projects V2 built-in workflows that
                             race against the orchestrator (destructive)
   --help                    Print this help
@@ -157,16 +171,24 @@ export function resolveOwnerForPicker(defaults, flags, env = process.env) {
   return null;
 }
 
-/** Ask a yes/no question. Non-interactive runs auto-accept (return true). */
-async function confirmYesNo(message, interactive) {
-  if (!interactive) return true;
+/**
+ * Ask a yes/no question. `defaultAnswer` controls the default when the
+ * operator presses Enter without typing (true = Y/n, false = y/N). In
+ * non-interactive mode the default is returned immediately.
+ */
+async function confirmYesNo(message, interactive, defaultAnswer = true) {
+  if (!interactive) return defaultAnswer;
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
   });
   try {
-    const raw = (await rl.question(`${message} [Y/n]: `)).trim().toLowerCase();
-    return raw === '' || raw === 'y' || raw === 'yes';
+    const hint = defaultAnswer ? '[Y/n]' : '[y/N]';
+    const raw = (await rl.question(`${message} ${hint}: `))
+      .trim()
+      .toLowerCase();
+    if (raw === '') return defaultAnswer;
+    return raw === 'y' || raw === 'yes';
   } finally {
     rl.close();
   }
@@ -688,6 +710,9 @@ async function runGithubBootstrap(answers, opts) {
     // interactive operator confirmation, `--assume-yes`, or
     // `--approve-github-admin`. Default-deny at the boundary gate when absent.
     githubAdminApproved: opts.githubAdminApproved === true,
+    // Opt-in: provision Status field + custom fields on the project board.
+    // Default off — prompted y/N during collect/confirm or via --with-project-board.
+    withProjectBoard: opts.withProjectBoard === true,
     // Opt-in: delete the Projects V2 built-in workflows that race against the
     // orchestrator's ColumnSync (e.g. "Pull request merged"). Off by default.
     reapConflictingWorkflows: Boolean(opts.reapConflictingWorkflows),
@@ -1011,7 +1036,48 @@ export async function collectAndConfirm(state) {
         return { ok: false, exit: 1 };
       }
     }
-    return { ok: true, payload: { answers, creation } };
+
+    // Opt-in: board decoration (Status field, custom fields). Default off.
+    // Dry-run halts immediately after this step — resolve without prompting.
+    let withProjectBoard = Boolean(state.flags['with-project-board']);
+    if (!state.flags['dry-run'] && !withProjectBoard) {
+      withProjectBoard = await confirmYesNo(
+        'Set up project board fields (Status, custom)?',
+        state.interactive,
+        false,
+      );
+    }
+
+    // Opt-in: GitHub Issue Form templates. Default off.
+    let withIssueForms = Boolean(state.flags['with-issue-forms']);
+    if (!state.flags['dry-run'] && !withIssueForms) {
+      withIssueForms = await confirmYesNo(
+        'Generate GitHub Issue Form templates?',
+        state.interactive,
+        false,
+      );
+    }
+
+    // Opt-in: local quality gates. Default off.
+    let withQuality = Boolean(state.flags['with-quality']);
+    if (!state.flags['dry-run'] && !withQuality) {
+      withQuality = await confirmYesNo(
+        'Install local quality gates (pre-commit hook + quality:preview/watch scripts)?',
+        state.interactive,
+        false,
+      );
+    }
+
+    return {
+      ok: true,
+      payload: {
+        answers,
+        creation,
+        withProjectBoard,
+        withIssueForms,
+        withQuality,
+      },
+    };
   }
 }
 
@@ -1157,7 +1223,8 @@ export async function executeBootstrap(state) {
     agentRoot: state.agentRoot,
     answers: state.answers,
     approvedGroups,
-    skipQuality: Boolean(state.flags['skip-quality']),
+    withQuality: state.withQuality === true,
+    withIssueForms: state.withIssueForms === true,
   });
   return { ok: true, payload: { report, approvedGroups } };
 }
@@ -1210,6 +1277,7 @@ export async function executeGithubBootstrap(state) {
     state.report.github = await runGithubBootstrap(state.answers, {
       assumeYes: state.assumeYes,
       githubAdminApproved: state.githubAdminApproved === true,
+      withProjectBoard: state.withProjectBoard === true,
       reapConflictingWorkflows: Boolean(
         state.flags['reap-conflicting-workflows'],
       ),
@@ -1232,7 +1300,7 @@ export function recordLedger(state) {
   const manifestCtx = {
     answers: state.answers,
     skipGithub: Boolean(state.flags['skip-github']),
-    skipQuality: Boolean(state.flags['skip-quality']),
+    withQuality: state.withQuality === true,
   };
   const entries = buildMutationManifest(manifestCtx).filter((e) =>
     appliedGroups.has(e.phaseGroup),
@@ -1384,7 +1452,7 @@ export async function main(argv = process.argv.slice(2), deps = {}) {
       `\n[Bootstrap] GitHub bootstrap failed: ${githubError}. ` +
         'Project-side setup (labels are GitHub-side; the local .agentrc.json / ' +
         'quality-gate / workflow files that were applied are recorded in the ' +
-        'install ledger) completed, but the GitHub label/board/views/protection ' +
+        'install ledger) completed, but the GitHub label/board/protection ' +
         'setup did not. Resolve the cause above (commonly `gh auth login` or a ' +
         'missing repo/project scope) and re-run `mandrel bootstrap` — the run is ' +
         'idempotent and will skip what already succeeded.',

package/.agents/scripts/lib/bootstrap/manifest.js

@@ -94,14 +94,14 @@ export const MANIFEST_ENTRY_FIELDS = Object.freeze([
  * platform; remote targets are scoped to the resolved `owner/repo` slug.
  *
  * The `github-admin` group is omitted when `ctx.skipGithub` is set, and the
- * `quality-gates` group is omitted when `ctx.skipQuality` is set, so the
- * preview reflects the same flags the executing pipeline honours.
+ * `quality-gates` group is included only when `ctx.withQuality` is true, so
+ * the preview reflects the same flags the executing pipeline honours.
  *
  * @param {object} [ctx]
  * @param {{ owner?: string, repo?: string }} [ctx.answers] — scopes the
  *   `github-admin` targets to the `owner/repo` slug.
  * @param {boolean} [ctx.skipGithub] — omit the `github-admin` group.
- * @param {boolean} [ctx.skipQuality] — omit the `quality-gates` group.
+ * @param {boolean} [ctx.withQuality] — include the `quality-gates` group.
  * @returns {MutationManifestEntry[]}
  */
 export function buildMutationManifest(ctx = {}) {
@@ -189,8 +189,8 @@ export function buildMutationManifest(ctx = {}) {
 
   // --- quality-gates ----------------------------------------------------
   // Stabilized quality-gate surface (husky pre-commit, quality npm
-  // scripts, .agentrc quality defaults).
-  if (!ctx.skipQuality) {
+  // scripts, .agentrc quality defaults). Included only when opted in.
+  if (ctx.withQuality) {
     entries.push(
       {
         phaseGroup: PHASE_GROUPS.QUALITY_GATES,

package/.agents/scripts/lib/bootstrap/project-bootstrap.js

@@ -724,7 +724,10 @@ export const BOOTSTRAP_PHASES = Object.freeze([
   {
     name: 'issueForms',
     phaseGroup: PHASE_GROUPS.REPO_CONFIG,
-    run: (ctx) => ensureIssueFormsPhase(ctx),
+    run: (ctx) =>
+      ctx.withIssueForms === true
+        ? ensureIssueFormsPhase(ctx)
+        : { skipped: true, reason: 'issue-forms-not-opted-in' },
   },
   {
     name: 'sync',
@@ -742,9 +745,9 @@ export const BOOTSTRAP_PHASES = Object.freeze([
     name: 'quality',
     phaseGroup: PHASE_GROUPS.QUALITY_GATES,
     run: (ctx) =>
-      ctx.skipQuality
-        ? { skipped: true }
-        : applyQualityBootstrap({ projectRoot: ctx.projectRoot }),
+      ctx.withQuality === true
+        ? applyQualityBootstrap({ projectRoot: ctx.projectRoot })
+        : { skipped: true, reason: 'quality-not-opted-in' },
   },
   {
     name: 'winPerf',
@@ -844,7 +847,7 @@ export async function runPhases(phases, ctx) {
  * @param {Set<string>} [ctx.approvedGroups] — when present, only phases
  *   whose `phaseGroup` is in this set execute (the consent-first gate from
  *   Story #3524); always-run infrastructure phases ignore it.
- * @param {boolean} [ctx.skipQuality]
+ * @param {boolean} [ctx.withQuality]
  * @param {boolean} [ctx.skipGithub]
  * @param {boolean} [ctx.skipInstall]
  * @param {boolean} [ctx.quiet]

package/.agents/scripts/lib/bootstrap/prompt.js

@@ -41,7 +41,7 @@ export const KNOWN_FLAGS = Object.freeze({
     'assume-yes',
     'approve-github-admin',
     'skip-github',
-    'skip-quality',
+    'with-quality',
     'help',
     'dry-run',
     'reap-conflicting-workflows',

package/.agents/scripts/lib/bootstrap/summary.js

@@ -57,12 +57,6 @@ export function printSummary(result) {
   Logger.info(`Fields skipped: ${result.fields.skipped.length}`);
   Logger.info(`Project: ${formatProjectSummary(result.project)}`);
   Logger.info(`Status field: ${result.statusField.status}`);
-  const unavailableSuffix = result.views.unavailable
-    ? ' (mutation unavailable)'
-    : '';
-  Logger.info(
-    `Views — created: ${result.views.created.length}, skipped: ${result.views.skipped.length}${unavailableSuffix}`,
-  );
   Logger.info(
     `Workflow audit: ${formatWorkflowAuditSummary(result.workflowAudit)}`,
   );

package/.agents/scripts/lib/bootstrap/workflow-audit.js

@@ -36,6 +36,8 @@
  *   {@link reapConflictingWorkflows}.
  */
 
+import { resolveProjectMeta } from '../orchestration/project-meta-resolver.js';
+
 /**
  * Workflows that **must not** be enabled when the orchestrator owns
  * the Status column. Each entry writes Status as a side-effect of an
@@ -207,14 +209,23 @@ export async function reapConflictingWorkflows(args) {
 }
 
 /**
- * Resolve a Project v2 node id from a project number against the viewer
- * scope. Used by the bootstrap CLI to convert the resolver's
- * `projectNumber` into the node id required by
- * {@link auditProjectWorkflows}. Returns `null` when the viewer cannot
- * see the project (e.g. missing scope, project not under viewer) so the
- * caller can degrade gracefully.
+ * Resolve a Project v2 node id from a project number. Used by the
+ * bootstrap CLI to convert the resolver's `projectNumber` into the node
+ * id required by {@link auditProjectWorkflows}.
+ *
+ * Walks the shared owner-type ladder — `organization(login:$owner)` →
+ * `user(login:$owner)` → `viewer` — via {@link resolveProjectMeta}, so an
+ * **org-owned** board resolves here the same way it does for `ColumnSync`
+ * (Story #4237). The owner login is read from `provider.projectOwner`
+ * (explicit board owner) and falls back to `provider.owner` (the repo
+ * owner) so org boards resolve even when no separate `projectOwner` is
+ * configured. Returns `null` when no owner scope can see the project
+ * (e.g. missing scope) so the caller can degrade gracefully.
  *
- * @param {{ provider: { graphql: Function }, projectNumber: number }} args
+ * @param {{
+ *   provider: { graphql: Function, owner?: string|null, projectOwner?: string|null },
+ *   projectNumber: number,
+ * }} args
  * @returns {Promise<string|null>}
  */
 export async function resolveProjectIdByNumber(args) {
@@ -230,11 +241,13 @@ export async function resolveProjectIdByNumber(args) {
     );
   }
   try {
-    const data = await provider.graphql(
-      `query($n: Int!) { viewer { projectV2(number: $n) { id } } }`,
-      { n: projectNumber },
-    );
-    return data?.viewer?.projectV2?.id ?? null;
+    const project = await resolveProjectMeta({
+      provider,
+      owner: provider.projectOwner ?? provider.owner ?? null,
+      projectNumber,
+      projectFields: 'id',
+    });
+    return project?.id ?? null;
   } catch {
     return null;
   }

package/.agents/scripts/lib/label-taxonomy.js

@@ -156,40 +156,3 @@ export const PROJECT_FIELD_DEFS = [
  * @type {string[]}
  */
 export const STATUS_FIELD_OPTIONS = ['Todo', 'In Progress', 'Done'];
-
-/**
- * Default Projects V2 saved Views. Filter strings follow GitHub's Projects
- * search syntax (`label:`, `status:`, `assignee:`). Each is grouped by the
- * Status field to match the board's columnar layout.
- *
- * GitHub's GraphQL surface does not expose a public `createProjectV2View`
- * mutation, so bootstrap creates these via the REST Projects V2 views
- * endpoint best-effort; when the endpoint is unavailable the views must be
- * configured manually in the GitHub Projects UI.
- *
- * @type {Array<{ name: string, filter: string, groupBy: string,
- *   layout?: 'table'|'board'|'roadmap' }>}
- */
-export const PROJECT_VIEW_DEFS = [
-  {
-    name: 'Mandrel Board',
-    filter: '',
-    groupBy: 'Status',
-    layout: 'board',
-  },
-  {
-    name: 'Epic Roadmap',
-    filter: 'label:type::epic',
-    groupBy: 'Status',
-  },
-  {
-    name: 'Active Stories',
-    filter: 'label:type::story -status:Done',
-    groupBy: 'Status',
-  },
-  {
-    name: 'My Queue',
-    filter: 'assignee:@me',
-    groupBy: 'Status',
-  },
-];

package/.agents/scripts/lib/onboard/init-tail.js

@@ -62,23 +62,22 @@ function formatMissingList(missing) {
 }
 
 /** Prompt text shown only on a TTY when asking to scaffold. */
-const SCAFFOLD_PROMPT = '\nCreate placeholders? [Y/n]: ';
+const SCAFFOLD_PROMPT = '\nCreate placeholders? [y/N]: ';
 
 /**
  * Async y/N read from stdin via `node:readline` (mirrors the prompt mechanism
  * in `bootstrap.js`). Returns on Enter and never blocks waiting for EOF the way
  * `fs.readFileSync(0)` did — that EOF-blocking read hung `mandrel init` on an
- * interactive TTY. Yes is the default (`[Y/n]`): a bare Enter — or anything but
- * an explicit `n`/`no` — resolves to `true` (create the placeholders), since the
- * missing docs are known-needed and the stubs carry a `MANDREL:STUB` marker the
- * `/plan` preflight still flags until they are fleshed out. A read error
- * resolves to `false` so a genuine I/O failure never writes unattended. The
- * prompt text is written by the caller via `stdout`, so the question string
- * passed here is empty.
+ * interactive TTY. No is the default (`[y/N]`): only an explicit `y`/`yes`
+ * resolves to `true` (create the placeholders). A bare Enter or any other input
+ * declines, matching the same default-off policy as `--with-issue-forms`. A
+ * read error resolves to `false` so a genuine I/O failure never writes
+ * unattended. The prompt text is written by the caller via `stdout`, so the
+ * question string passed here is empty.
  *
  * `terminal: false` is **load-bearing**: with terminal mode on (the default
  * when stdout is a TTY) readline emits cursor-control escapes
- * (`\x1b[1G\x1b[0J`) that erase the `Create placeholders? [Y/n]:` prompt already
+ * (`\x1b[1G\x1b[0J`) that erase the `Create placeholders? [y/N]:` prompt already
  * written via the caller's `stdout`, leaving the operator staring at a blank,
  * dead-looking line. Disabling terminal mode preserves the pre-written prompt
  * and reads the line via the TTY's cooked-mode echo. `createInterface` is
@@ -97,7 +96,7 @@ export async function readConfirm({
   });
   try {
     const answer = (await rl.question('')).trim().toLowerCase();
-    return answer !== 'n' && answer !== 'no';
+    return answer === 'y' || answer === 'yes';
   } catch {
     return false;
   } finally {

package/.agents/scripts/lib/orchestration/column-sync.js

@@ -35,6 +35,7 @@
  */
 
 import { AGENT_LABELS } from '../label-constants.js';
+import { resolveProjectMeta } from './project-meta-resolver.js';
 
 export const LABEL_TO_COLUMN = Object.freeze({
   [AGENT_LABELS.REVIEW_SPEC]: 'Todo',
@@ -141,49 +142,29 @@ export class ColumnSync {
   async #loadMeta() {
     if (this._meta !== null) return this._meta || null;
     try {
-      let project;
-      if (this.projectOwner) {
-        // When the project is owned by a different account than the
-        // authenticated viewer, `viewer.projectV2` returns null. Use
-        // `user(login: $owner).projectV2` instead. (Story #3560)
-        const data = await this.provider.graphql(
-          `
-          query($owner: String!, $number: Int!) {
-            user(login: $owner) {
-              projectV2(number: $number) {
-                id
-                field(name: "Status") {
-                  ... on ProjectV2SingleSelectField {
-                    id
-                    options { id name }
-                  }
-                }
-              }
+      // Resolve the board by walking the owner-type ladder
+      // (organization → user → viewer) via the shared resolver so the
+      // org-owned path can't drift from `workflow-audit.js`. The Status
+      // single-select field is projected alongside the board id in one
+      // round-trip. (Story #4237; org-owner support extends the
+      // user/viewer ladder added in #3560.)
+      const project = await resolveProjectMeta({
+        provider: this.provider,
+        // Prefer the explicit `github.projectOwner`; fall back to the repo
+        // owner so an org-owned board still gets a login to scope
+        // `organization(login:)` / `user(login:)` by even when no separate
+        // projectOwner is configured. `viewer` is always the final rung.
+        owner: this.projectOwner ?? this.provider.owner ?? null,
+        projectNumber: this.projectNumber,
+        projectFields: `
+          id
+          field(name: "Status") {
+            ... on ProjectV2SingleSelectField {
+              id
+              options { id name }
             }
           }`,
-          { owner: this.projectOwner, number: this.projectNumber },
-        );
-        project = data?.user?.projectV2;
-      } else {
-        const data = await this.provider.graphql(
-          `
-          query($number: Int!) {
-            viewer {
-              projectV2(number: $number) {
-                id
-                field(name: "Status") {
-                  ... on ProjectV2SingleSelectField {
-                    id
-                    options { id name }
-                  }
-                }
-              }
-            }
-          }`,
-          { number: this.projectNumber },
-        );
-        project = data?.viewer?.projectV2;
-      }
+      });
       const field = project?.field;
       if (!project || !field) {
         this._meta = false;

package/.agents/scripts/lib/orchestration/epic-spec-reconciler-discriminator.js

@@ -45,7 +45,7 @@
  * @property {string}  [reason]   Structured reason code when allowed=false.
  */
 
-import { AGENT_LABELS } from '../label-constants.js';
+import { AGENT_LABELS, TYPE_LABELS } from '../label-constants.js';
 
 /**
  * Execution-signal labels that block Close. Stored as a frozen Set for
@@ -245,6 +245,57 @@ export class LabelAllowListViolation extends Error {
   }
 }
 
+/**
+ * Error class thrown synchronously by `assertStoryTypeLabel` when a Story
+ * create operation carries no `type::story` label. Named distinctly from
+ * `LabelAllowListViolation` so callers can route it separately.
+ *
+ * The class carries structured metadata (`slug`, `title`) so the error
+ * message can name the offending Story clearly.
+ */
+export class MissingTypeLabelError extends Error {
+  /**
+   * @param {string} message
+   * @param {{slug?: string, title?: string}} [meta]
+   */
+  constructor(message, meta = {}) {
+    super(message);
+    this.name = 'MissingTypeLabelError';
+    if (meta.slug !== undefined) this.slug = meta.slug;
+    if (meta.title !== undefined) this.title = meta.title;
+  }
+}
+
+/**
+ * Diff-time assertion. Throws `MissingTypeLabelError` synchronously when a
+ * Story create operation is missing the mandatory `type::story` label.
+ *
+ * Symmetric with `assertNoAgentLabels`: both fire at diff time so the plan
+ * fails loudly before the apply pipeline touches GitHub.
+ *
+ * Only validates Story create ops — Epic creates carry a different mandatory
+ * label (`type::epic`) that the caller already hard-codes at issue-creation
+ * time; the assertion is not needed there.
+ *
+ * @param {{slug?: string, title?: string, entity?: string, labels?: string[]}} op
+ * @returns {void}
+ */
+export function assertStoryTypeLabel(op) {
+  if (!op || typeof op !== 'object') return;
+  if (op.entity !== 'story') return;
+  // A create op for a Story MUST carry type::story. An absent or empty labels
+  // array means the mandatory label is missing — fail loud so the operator
+  // sees a named Story rather than a silent unlabeled issue on GitHub.
+  if (!Array.isArray(op.labels) || !op.labels.includes(TYPE_LABELS.STORY)) {
+    throw new MissingTypeLabelError(
+      `create plan for story slug=${op.slug ?? '?'} ("${op.title ?? ''}") is ` +
+        `missing the mandatory "${TYPE_LABELS.STORY}" label. Add it to the ` +
+        `spec's labels array for this Story and re-run.`,
+      { slug: op.slug, title: op.title },
+    );
+  }
+}
+
 /**
  * Diff-time assertion. Throws `LabelAllowListViolation` synchronously
  * when an operation targets an `agent::*` label. The assertion is the
@@ -329,7 +380,10 @@ export function assertNoAgentLabels(op) {
  */
 export function assertPlanLabelAllowList(plan) {
   if (!plan || typeof plan !== 'object') return;
-  for (const op of plan.creates ?? []) assertNoAgentLabels(op);
+  for (const op of plan.creates ?? []) {
+    assertNoAgentLabels(op);
+    assertStoryTypeLabel(op);
+  }
   for (const op of plan.updates ?? []) assertNoAgentLabels(op);
   // closes/relinks do not carry label payloads — nothing to assert.
 }

package/.agents/scripts/lib/orchestration/project-meta-resolver.js

@@ -0,0 +1,129 @@
+/**
+ * project-meta-resolver — shared GitHub Projects v2 owner-resolution
+ * primitive (Story #4237).
+ *
+ * Background:
+ *   Both `ColumnSync._loadMeta` (`lib/orchestration/column-sync.js`) and
+ *   `resolveProjectIdByNumber` (`lib/bootstrap/workflow-audit.js`)
+ *   needed to turn a `(owner, projectNumber)` pair into a Projects v2
+ *   board node id. Each historically resolved only **user-owned** /
+ *   `viewer`-owned boards: `viewer.projectV2(number:)` first, then
+ *   `user(login:$owner).projectV2(number:)` (Story #3560). Neither had an
+ *   `organization(login:$owner)` branch, so for an **org-owned** board
+ *   every lookup failed with `NOT_FOUND` and the `agent::*` → board
+ *   Status mirror silently no-oped (reproduced on `Beestera/swarm-os`).
+ *
+ * Fix:
+ *   A single shared resolver that walks the owner-type ladder in order —
+ *   `organization(login:$owner)` → `user(login:$owner)` → `viewer` —
+ *   returning the first board it can resolve. Centralising the ladder in
+ *   one place means the org path can never again drift between the two
+ *   call sites.
+ *
+ * The resolver issues a sub-query for the project itself (`field(name:
+ * "Status") { … }` for the column-sync caller, or a bare `id` for the
+ * workflow-audit caller). Pass the desired projection in via
+ * `projectFields`; the resolver wraps it in the right owner scope and
+ * extracts the resolved `projectV2` node.
+ */
+
+/**
+ * The owner-resolution ladder, in priority order. Each entry names the
+ * GraphQL root field and whether it requires the `$owner` variable.
+ *
+ * `organization` and `user` are keyed by `login: $owner`; `viewer` is the
+ * authenticated identity and takes no owner argument. The viewer rung is
+ * the historical default and stays last so a configured owner is always
+ * preferred over the ambient identity.
+ */
+const OWNER_SCOPES = Object.freeze([
+  { root: 'organization', needsOwner: true },
+  { root: 'user', needsOwner: true },
+  { root: 'viewer', needsOwner: false },
+]);
+
+/**
+ * Build the GraphQL document for a single owner scope.
+ *
+ * @param {{ root: string, needsOwner: boolean }} scope
+ * @param {string} projectFields — the inner `projectV2(number: $number) { … }`
+ *   selection body (everything between the braces).
+ * @returns {string}
+ */
+function buildScopedQuery(scope, projectFields) {
+  if (scope.needsOwner) {
+    return `
+      query($owner: String!, $number: Int!) {
+        ${scope.root}(login: $owner) {
+          projectV2(number: $number) {
+            ${projectFields}
+          }
+        }
+      }`;
+  }
+  return `
+    query($number: Int!) {
+      ${scope.root} {
+        projectV2(number: $number) {
+          ${projectFields}
+        }
+      }
+    }`;
+}
+
+/**
+ * Resolve a Projects v2 board node by walking the owner-type ladder.
+ *
+ * Tries `organization(login:$owner)` → `user(login:$owner)` → `viewer` in
+ * order, returning the first non-null `projectV2` node. A scope that
+ * throws (e.g. GitHub returns `NOT_FOUND` for the wrong owner type) or
+ * resolves to `null` is treated as a miss and the ladder advances to the
+ * next rung. Returns `null` when every rung misses.
+ *
+ * When `owner` is falsy, only the `viewer` rung is attempted (there is no
+ * login to scope `organization`/`user` by) — this preserves the original
+ * viewer-only behaviour for callers that never configured a project owner.
+ *
+ * @param {{
+ *   provider: { graphql: Function },
+ *   owner?: string | null,
+ *   projectNumber: number,
+ *   projectFields: string,
+ * }} args
+ * @returns {Promise<object|null>} the resolved `projectV2` node, or null.
+ */
+export async function resolveProjectMeta(args) {
+  const { provider, owner, projectNumber, projectFields } = args ?? {};
+  if (!provider || typeof provider.graphql !== 'function') {
+    throw new TypeError('resolveProjectMeta requires a provider with graphql');
+  }
+  if (typeof projectFields !== 'string' || projectFields.length === 0) {
+    throw new TypeError(
+      'resolveProjectMeta requires a projectFields selection',
+    );
+  }
+
+  for (const scope of OWNER_SCOPES) {
+    // Skip the owner-scoped rungs when no owner login is available.
+    if (scope.needsOwner && !owner) continue;
+
+    const query = buildScopedQuery(scope, projectFields);
+    const vars = scope.needsOwner
+      ? { owner, number: projectNumber }
+      : { number: projectNumber };
+
+    let data;
+    try {
+      data = await provider.graphql(query, vars);
+    } catch {
+      // Wrong owner type (NOT_FOUND), missing scope, etc. — advance the
+      // ladder rather than aborting the whole resolution.
+      continue;
+    }
+
+    const node = data?.[scope.root]?.projectV2;
+    if (node) return node;
+  }
+
+  return null;
+}

package/.agents/scripts/providers/github/project-board.js

@@ -2,11 +2,11 @@
  * GitHub Provider — ProjectBoardGateway.
  *
  * Owns the Projects V2 bootstrap surface: `resolveOrCreateProject`,
- * `ensureStatusField`, `ensureProjectViews`, `ensureProjectFields`. The
- * low-level GraphQL mutations live in `./projects-v2-graphql.js`; this
- * class threads the parent provider's `_ctx` (which carries `projectNumber`,
- * `projectOwner`, `state`, and the shared cache) into each call so the
- * legacy shim contract is preserved.
+ * `ensureStatusField`, `ensureProjectFields`. The low-level GraphQL
+ * mutations live in `./projects-v2-graphql.js`; this class threads the
+ * parent provider's `_ctx` (which carries `projectNumber`, `projectOwner`,
+ * `state`, and the shared cache) into each call so the legacy shim contract
+ * is preserved.
  *
  * Extracted from `../github.js` in Story #2462 / Task #2479. Public
  * surface on `GitHubProvider` is unchanged — every project-board method
@@ -36,10 +36,6 @@ export class ProjectBoardGateway {
     return projects.ensureStatusField(this._ctx, optionNames);
   }
 
-  async ensureProjectViews(viewDefs) {
-    return projects.ensureProjectViews(this._ctx, viewDefs);
-  }
-
   /* node:coverage ignore next */
   async ensureProjectFields(fieldDefs) {
     return projects.ensureProjectFields(this._ctx, fieldDefs);

package/.agents/scripts/providers/github/projects-v2-graphql.js

@@ -21,14 +21,8 @@ const Q_PROJ = (scope, fields) =>
 const M_PROJ = `mutation($ownerId:ID!,$title:String!){createProjectV2(input:{ownerId:$ownerId,title:$title}){projectV2{id number}}}`;
 const M_FIELD = `mutation($projectId:ID!,$name:String!,$options:[ProjectV2SingleSelectFieldOptionInput!]!){createProjectV2Field(input:{projectId:$projectId,dataType:SINGLE_SELECT,name:$name,singleSelectOptions:$options}){projectV2Field{... on ProjectV2SingleSelectField{id name}}}}`;
 const M_UPDATE = `mutation($fieldId:ID!,$name:String!,$options:[ProjectV2SingleSelectFieldOptionInput!]!){updateProjectV2Field(input:{fieldId:$fieldId,name:$name,singleSelectOptions:$options}){projectV2Field{... on ProjectV2SingleSelectField{id name}}}}`;
-// Projects V2 view creation uses the REST API — the GraphQL
-// `createProjectV2View` mutation is not generally available. Endpoints:
-//   org-owned:  POST /orgs/{org}/projectsV2/{number}/views        ({org} login)
-//   user-owned: POST /users/{user_id}/projectsV2/{number}/views   (numeric id)
-const REST_API_VERSION = '2026-03-10';
 const M_ITEM = `mutation($projectId:ID!,$contentId:ID!){addProjectV2ItemById(input:{projectId:$projectId,contentId:$contentId}){item{id}}}`;
 const F_STATUS = `id fields(first:50){nodes{... on ProjectV2SingleSelectField{id name options{id name}}}}`;
-const F_VIEWS = `id views(first:50){nodes{name}}`;
 const F_FIELDS = `id fields(first:50){nodes{... on ProjectV2Field{name} ... on ProjectV2IterationField{name} ... on ProjectV2SingleSelectField{name}}}`;
 const SCOPES_RE =
   /INSUFFICIENT_SCOPES|Resource not accessible by personal access token|your token has not been granted the required scopes/i;
@@ -106,97 +100,6 @@ async function gql(ctx, query, variables, { retry = false } = {}) {
   return retry ? withTransientRetry(run) : run();
 }
 
-/**
- * Issue a REST request against api.github.com, reusing the same token and
- * fetch seam as `gql`. Throws on non-2xx with the response body for context.
- * Pass `{ retry: true }` to retry transient network blips (idempotent calls).
- */
-async function rest(ctx, method, apiPath, body, { retry = false } = {}) {
-  const run = async () => {
-    const fetchImpl = ctx.fetchImpl ?? globalThis.fetch;
-    const response = await fetchImpl(`https://api.github.com${apiPath}`, {
-      method,
-      headers: {
-        Accept: 'application/vnd.github+json',
-        Authorization: `Bearer ${ctx.token ?? resolveToken()}`,
-        'Content-Type': 'application/json',
-        'User-Agent': 'node.js',
-        'X-GitHub-Api-Version': REST_API_VERSION,
-      },
-      ...(body ? { body: JSON.stringify(body) } : {}),
-    });
-    if (!response.ok) {
-      const text = await response.text().catch(() => '');
-      const err = new Error(
-        `[GitHubProvider] REST ${method} ${apiPath} → ${response.status}: ${text}`,
-      );
-      err.status = response.status;
-      throw err;
-    }
-    return response.json().catch(() => ({}));
-  };
-  return retry ? withTransientRetry(run) : run();
-}
-
-/**
- * Resolve an owner login to its account type and numeric id via
- * `GET /users/{login}` (which serves both users and orgs). The REST views
- * endpoint keys orgs by login but users by numeric id, so we need both.
- */
-async function resolveOwnerAccount(ctx, owner) {
-  const data = await rest(
-    ctx,
-    'GET',
-    `/users/${encodeURIComponent(owner)}`,
-    undefined,
-    { retry: true },
-  );
-  return { id: data?.id ?? null, type: data?.type ?? null };
-}
-
-/**
- * Build the candidate REST views endpoints to try, in order. Orgs key by
- * login. For user-owned projects the docs label the path param `{user_id}`
- * but it's ambiguous (numeric id vs login) and the numeric form was observed
- * to 404 — so we try the login first (mirroring the org endpoint) then fall
- * back to the numeric id, treating a 404 as "wrong param, try the next".
- */
-function viewsEndpoints(account, owner, projectNumber) {
-  if (account.type === 'Organization') {
-    return [
-      `/orgs/${encodeURIComponent(owner)}/projectsV2/${projectNumber}/views`,
-    ];
-  }
-  const candidates = [];
-  if (owner) {
-    candidates.push(
-      `/users/${encodeURIComponent(owner)}/projectsV2/${projectNumber}/views`,
-    );
-  }
-  if (account.id != null) {
-    candidates.push(`/users/${account.id}/projectsV2/${projectNumber}/views`);
-  }
-  return candidates;
-}
-
-/**
- * POST a view to the first candidate endpoint that does not 404. A 404 means
- * the path param shape was wrong (login vs numeric id) — try the next. Any
- * other status is a real failure and propagates.
- */
-async function createView(ctx, endpoints, body) {
-  let lastError = null;
-  for (const endpoint of endpoints) {
-    try {
-      return await rest(ctx, 'POST', endpoint, body, { retry: true });
-    } catch (err) {
-      lastError = err;
-      if (err.status !== 404) throw err;
-    }
-  }
-  throw lastError ?? new Error('[GitHubProvider] No views endpoint available.');
-}
-
 async function lookupProject(ctx, fragment, strict = false) {
   if (!ctx.projectNumber) return null;
   let lastError = null;
@@ -357,75 +260,6 @@ export async function ensureStatusField(ctx, optionNames) {
   }
 }
 
-export async function ensureProjectViews(ctx, viewDefs) {
-  if (!ctx.projectNumber)
-    throw new Error(
-      '[GitHubProvider] ensureProjectViews requires projectNumber.',
-    );
-  const created = [],
-    skipped = [];
-  let project;
-  try {
-    project = await lookupProject(ctx, F_VIEWS, true);
-  } catch {
-    return {
-      created,
-      skipped: viewDefs.map((view) => view.name),
-      unavailable: true,
-    };
-  }
-  if (!project)
-    throw new Error(
-      `[GitHubProvider] Project #${ctx.projectNumber} not found for ${ctx.projectOwner}.`,
-    );
-  const existingViewNames = new Set(
-    (project.views?.nodes ?? []).map((view) => view?.name).filter(Boolean),
-  );
-
-  // Resolve the owner account once to pick the right REST endpoint shape.
-  let account;
-  try {
-    account = await resolveOwnerAccount(ctx, ctx.projectOwner);
-  } catch (err) {
-    return {
-      created,
-      skipped: viewDefs.map((view) => view.name),
-      unavailable: true,
-      error: err.message,
-    };
-  }
-
-  const endpoints = viewsEndpoints(
-    account,
-    ctx.projectOwner,
-    ctx.projectNumber,
-  );
-  let unavailable = false;
-  let error;
-  for (const def of viewDefs) {
-    if (existingViewNames.has(def.name) || unavailable) {
-      skipped.push(def.name);
-      continue;
-    }
-    try {
-      await createView(ctx, endpoints, {
-        name: def.name,
-        // PROJECT_VIEW_DEFS predate REST layouts; the GraphQL path always
-        // created board views, so default to 'board' (override via
-        // `def.layout` = 'table' | 'board' | 'roadmap').
-        layout: def.layout ?? 'board',
-        ...(def.filter ? { filter: def.filter } : {}),
-      });
-      created.push(def.name);
-    } catch (err) {
-      unavailable = true;
-      error = err.message;
-      skipped.push(def.name);
-    }
-  }
-  return { created, skipped, unavailable, ...(error ? { error } : {}) };
-}
-
 export async function ensureProjectFields(ctx, fieldDefs) {
   if (!ctx.projectNumber) return { created: [], skipped: [] };
   const project = await lookupProject(ctx, F_FIELDS);

package/.agents/scripts/providers/github/tickets.js

@@ -23,6 +23,7 @@
 
 import { parseBlockedBy, parseBlocks } from '../../lib/dependency-parser.js';
 import { Logger } from '../../lib/Logger.js';
+import { TYPE_LABELS } from '../../lib/label-constants.js';
 import { addIssueToBoard } from './board-add.js';
 import { createInlineTicketCache } from './cache.js';
 import { withTransientRetry } from './errors.js';
@@ -318,13 +319,21 @@ export class TicketGateway {
       dependencies: ticketData.dependencies ?? [],
     });
 
+    // Mirror the Epic create path (issues.js:160 → `labels: TYPE_LABELS.EPIC`):
+    // always inject TYPE_LABELS.STORY so a spec that omits the labels array
+    // cannot produce an unlabeled, undispatchable Story. Dedupe to avoid
+    // duplicates when the caller already carries the label.
+    const callerLabels = ticketData.labels ?? [];
+    const labels = callerLabels.includes(TYPE_LABELS.STORY)
+      ? callerLabels
+      : [TYPE_LABELS.STORY, ...callerLabels];
     const result = await this._gh.api({
       method: 'POST',
       endpoint: `/repos/${this.owner}/${this.repo}/issues`,
       body: {
         title: ticketData.title,
         body: renderedBody,
-        labels: ticketData.labels ?? [],
+        labels,
       },
     });
     const issue = parseApiJson(result);

package/.agents/scripts/providers/github.js

@@ -130,7 +130,6 @@ const DELEGATIONS = [
   ['setMergeMethods', 'mergeMethods.setMergeMethods'],
   ['resolveOrCreateProject', 'projectBoard.resolveOrCreateProject'],
   ['ensureStatusField', 'projectBoard.ensureStatusField'],
-  ['ensureProjectViews', 'projectBoard.ensureProjectViews'],
   ['ensureProjectFields', 'projectBoard.ensureProjectFields'],
 ];
 for (const [name, target] of DELEGATIONS) {

package/docs/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.74.0](https://github.com/dsj1984/mandrel/compare/mandrel-v1.73.0...mandrel-v1.74.0) (2026-06-19)
+
+
+### Added
+
+* minimize install footprint: drop Project views, make the board + custom-fields + issue-forms decoration opt-in (default off) ([#4234](https://github.com/dsj1984/mandrel/issues/4234)) ([#4235](https://github.com/dsj1984/mandrel/issues/4235)) ([9c8acf6](https://github.com/dsj1984/mandrel/commit/9c8acf6f8b324d3d2c221031f636680c823d5c2a))
+
+
+### Fixed
+
+* **bootstrap:** make quality gates and docs-stub scaffold opt-in and default-off ([#4240](https://github.com/dsj1984/mandrel/issues/4240)) ([e41da73](https://github.com/dsj1984/mandrel/commit/e41da7343e7fc1b55d1e1749f2e532b231426766))
+* **decompose:** enforce/default the mandatory type::story label on Story create → no more unlabeled, undispatchable Stories ([#4241](https://github.com/dsj1984/mandrel/issues/4241)) ([#4242](https://github.com/dsj1984/mandrel/issues/4242)) ([14d3752](https://github.com/dsj1984/mandrel/commit/14d3752f0bf8ed1133508e5c1955e60afb8d8a24))
+* **projects:** resolve organization-owned Projects v2 boards (refs [#4237](https://github.com/dsj1984/mandrel/issues/4237)) ([#4238](https://github.com/dsj1984/mandrel/issues/4238)) ([3c033c3](https://github.com/dsj1984/mandrel/commit/3c033c36a03ca68c94be0cfbee991ef33e7fa14d))
+
 ## [1.73.0](https://github.com/dsj1984/mandrel/compare/mandrel-v1.72.0...mandrel-v1.73.0) (2026-06-17)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mandrel",
-  "version": "1.73.0",
+  "version": "1.74.0",
   "description": "Claude Code-first opinionated workflow framework: instructions, personas, skills, and SDLC workflows that govern AI coding assistants.",
   "files": [
     ".agents/",