@aperant/framework 0.9.0 → 0.11.0

package/skills/apt-catch-up/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: apt:catch-up
+description: "Re-view the catch-up panel (Welcome-Back + Team-Change Digest) on demand"
+apt-skill-version: {{APT_VERSION}}
+stage: resume
+intent: capture
+when_to_use: "The user dismissed the auto catch-up panel on their last /apt and wants to re-summon it — an idempotent re-view of where they left off plus what teammates merged. Distinct from /apt:resume (full context restore) and never advances the Last-Seen Marker."
+user_invocable: true
+internal: false
+spawns_agent: false
+agent_name: null
+task_context: none
+default_execution_mode: auto
+execution_modes:
+  - auto
+allowed-tools: "Bash, Read"
+argument-hint: "apt:catch-up"
+gates: []
+---
+<objective>
+Recompute and display the combined catch-up panel — the **Welcome-Back
+Summary** (your most-recently-active task, phase, next step) and the
+**Team-Change Digest** (the PRs teammates merged to main since you last
+pulled) — exactly as the auto-on-apt display would show it, but **without
+advancing the Last-Seen Marker**. This is a read-only re-view: a user who
+dismissed the auto panel can re-summon it without disturbing the baseline and
+without invoking the heavier `/apt:resume`.
+</objective>
+
+<your_environment>
+- **Working directory:** The project root (where you were invoked)
+- **apt-tools:** `node packages/framework/bin/apt-tools.mjs` or the installed `apt-tools` binary
+- **Last-Seen Marker:** `.aperant/last-seen/{email-slug}.json` (gitignored, per-machine) — this skill READS it but NEVER writes it.
+</your_environment>
+
+<process>
+
+## 1. Recompute the panel (read-only)
+
+```bash
+node packages/framework/bin/apt-tools.mjs catch-up .
+```
+
+This computes the SAME panel the interactive route call produces, against the
+**current** marker — and deliberately does **NOT** call `advanceLastSeen`
+(recompute-only contract). Parse the JSON `catch_up` field from the envelope.
+
+## 2. Render the panel
+
+Render exactly as the `apt/SKILL.md` "Catch-up panel" block does — Welcome-Back
+half first, then the Team-Change Digest half. Omit a half whose field is null.
+
+If `catch_up` is null, tell the user there is nothing new since their last
+visit (no active stale task and no new merges on main).
+
+```
+Where you left off: {description} — {lifecycle_phase} · subtask {current_subtask} ({relative_time})
+  Next: {next_step}
+  (+{others_count} others · /apt:resume)
+
+While you were away:
+  #{number} {title} — {author}
+  +{more_count} more on main
+```
+
+</process>
+
+<notes>
+- **Never advances the marker.** Unlike the auto-on-apt display (which advances
+  the Last-Seen Marker after the panel is evaluated), this command is purely a
+  re-view. Re-running it is idempotent.
+- **Distinct from `/apt:resume`.** Resume restores full context and routes to
+  the next action; catch-up is a lightweight orientation re-view.
+- **v1 is lazy compute.** The panel is computed on demand here, bounded by the
+  commits since your last pull. A background pre-warm worker (like the
+  update-check worker) is a tracked follow-up (LD-12), not part of v1.
+- **Vocabulary.** This is the Welcome-Back Summary + Team-Change Digest — not an
+  "activity feed", "changelog", or "notifications".
+</notes>

package/skills/apt-pr-review/SKILL.md

@@ -247,10 +247,11 @@ The command resolves in this precedence order:
 
 1. `config.json:pr_review.authorship_overrides['pr-${PR_NUMBER}']` (per-PR pin)
 2. `config.json:pr_review.authorship_override` (global: `owned` | `external` | `auto`)
-3. `gh pr view` → `authorAssociation` + `headRepository.owner.login` vs. viewer login
-   - `authorAssociation IN (OWNER, MEMBER, COLLABORATOR)` AND same-repo branch → **owned**
-   - Fork OR `authorAssociation IN (NONE, CONTRIBUTOR, FIRST_TIME_CONTRIBUTOR)` → **external**
-4. Offline / gh unavailable / ambiguous payload → **unknown**
+3. `gh pr view` → `gh.author.login` vs. viewer login (G44 — `owned` means a PR you **authored**, not a branch you can push to)
+   - Same-repo branch AND `gh.author.login === viewer login` → **owned**
+   - Any other same-repo PR (a teammate's, or a repo-`OWNER` viewing someone else's PR) → **external** (`authorAssociation` is no longer consulted for the `owned` decision — it is retained only in the human-readable signal)
+   - Fork (head-repo owner ≠ base-repo owner) → **external**
+4. Offline / gh unavailable / ambiguous payload → **unknown** (treated as `external` for safety, see below)
 
 When the result is `unknown`, treat it as `external` for safety and prompt the user:
 
@@ -469,6 +470,55 @@ fi
 
 After this point, the per-round artifact root is `.aperant/pr-reviews/pr-${PR_NUMBER}/rounds/${ROUND}/` (the `${REVIEW_ID}` is still used for the git worktree branch and temporary files). Subsequent `git diff` invocations within the round use `${PINNED_HEAD_SHA}` as the head ref.
 
+### Step 4c: Mergeability Pre-Check (PR reviews only)
+
+**Why this exists.** The review diff is `git diff {BASE}...{HEAD}` (three-dot — from the *merge-base*), so it shows the PR's own changes relative to where it branched. It is **blind to drift on `{BASE}` since then** and therefore says nothing about whether the PR still merges cleanly. A PR can pass a glowing review and be unmergeable. This step closes that gap: it is **informational, never blocking** (the review still runs in full), but a conflicting/stale state MUST be surfaced so the reader doesn't trust a review of a diff that no longer applies.
+
+```bash
+# PR-mode only. Query GitHub's authoritative mergeability + measure drift.
+if [ -n "$PR_NUMBER" ]; then
+  MERGE_JSON=$(gh pr view ${PR_NUMBER} --json mergeable,mergeStateStatus,baseRefName 2>/dev/null)
+  MERGEABLE=$(echo "$MERGE_JSON" | jq -r '.mergeable // "UNKNOWN"')
+  MERGE_STATE=$(echo "$MERGE_JSON" | jq -r '.mergeStateStatus // "UNKNOWN"')
+  BASE_REF=$(echo "$MERGE_JSON" | jq -r '.baseRefName // "main"')
+  git fetch origin "${BASE_REF}" 2>/dev/null
+  BEHIND=$(git rev-list --count ${PINNED_HEAD_SHA}..origin/${BASE_REF} 2>/dev/null || echo "?")
+  AHEAD=$(git rev-list --count origin/${BASE_REF}..${PINNED_HEAD_SHA} 2>/dev/null || echo "?")
+
+  # If GitHub reports a conflict (or hasn't computed yet), enumerate the conflicting
+  # files locally without touching any working tree (git >= 2.38):
+  CONFLICT_FILES=""
+  if [ "$MERGEABLE" = "CONFLICTING" ] || [ "$MERGE_STATE" = "DIRTY" ]; then
+    CONFLICT_FILES=$(git merge-tree --write-tree --name-only origin/${BASE_REF} ${PINNED_HEAD_SHA} 2>/dev/null \
+                     | tail -n +2 | sed '/^$/d' | grep '/' )
+  fi
+fi
+```
+
+Record the result in `metadata.json` under a `mergeability` key:
+
+```json
+{
+  "mergeability": {
+    "mergeable": "CONFLICTING | MERGEABLE | UNKNOWN",
+    "merge_state_status": "DIRTY | CLEAN | BLOCKED | BEHIND | ...",
+    "base_ref": "main",
+    "commits_behind_base": 101,
+    "commits_ahead_base": 91,
+    "conflicting_files": ["apps/.../App.tsx", "..."]
+  }
+}
+```
+
+**How to use the result:**
+
+- `MERGEABLE` ∈ {`CONFLICTING`} OR `MERGE_STATE` = `DIRTY` → the PR has conflicts. Surface a **⚠️ Mergeability** block in the Phase 5 intermediate report AND the Phase 8 final report, listing `commits_behind_base` and the `conflicting_files`. In **external / comment-only** mode, include the same block in the Phase 6b comment. State plainly that the branch needs a rebase/merge from `{BASE}` and that **the reviewed diff may be stale** with respect to current `{BASE}`.
+- `MERGE_STATE` = `BEHIND` (mergeable but behind) → note the drift (`commits_behind_base`) as a softer advisory; no conflict, but the diff predates recent `{BASE}` commits.
+- `MERGEABLE` = `UNKNOWN` (GitHub hasn't finished computing, common right after a push) → record `UNKNOWN`; optionally re-poll once after a few seconds. Do not block.
+- `MERGEABLE` = `MERGEABLE`, `MERGE_STATE` = `CLEAN` → record it and move on silently.
+
+This step never changes the review's findings or assessment — a conflicting PR with zero code findings is still `approve` on its own merits. Mergeability is reported as a **separate** signal so the reader knows whether the approval can actually land.
+
 ### Step 5: Read All Changed Files
 
 For every file in the changed file list, read it in full using the Read tool **from the worktree**:
@@ -1058,6 +1108,10 @@ Review Synthesis (Before Auto-Fix)
 Auto-Checks: {PASS/FAIL}
   lint: {P/F} | typecheck: {P/F} | tests: {P/F}
 
+Mergeability (PR reviews — from Step 4c): {MERGEABLE/CONFLICTING/UNKNOWN}
+  {if CONFLICTING/DIRTY: "⚠️ conflicts with {BASE} — {behind} commits behind — needs rebase — reviewed diff may be stale"}
+  {if conflicting_files: list them}
+
 Validated Findings:
   CRITICAL: {N}
   HIGH: {N}
@@ -1630,6 +1684,7 @@ Output the human-readable summary:
 
   Review ID: {REVIEW_ID}
   Assessment: {APPROVE / REQUEST CHANGES / COMMENT}
+  Mergeability: {MERGEABLE / CONFLICTING (N behind {BASE}, needs rebase) / UNKNOWN}   # PR reviews — from Step 4c / metadata.json.mergeability
 
   Scores:
     Security:      {score}/10

package/skills/apt-setup/SKILL.md

@@ -205,6 +205,7 @@ AskUserQuestion([
 - "Visibility" → jump to **Step 3e** (Batch 6 only), then skip to **Step 4** and **Step 5**
 - "Task Tracking" → jump to **Step 3g** (Batch 8 only), then skip to **Step 4** and **Step 5**
 - "Changelog & Release Notes" → jump to **Step 3h** (Batch 9 only), then skip to **Step 4** and **Step 5**
+- "Collaboration" → jump to **Step 3i** (Batch 10 only), then skip to **Step 4** and **Step 5**
 - "Everything" → proceed to **Step 2** and run all batches (same as fresh setup). **Legacy-completes-Everything marker write:** if the starting config has no `onboarding` block (legacy unmarked config) and the user completes the full flow, write a full `onboarding` block at Step 5 as `{ completed: true, seeded_from_template: false, seeded_at: <ISO-8601 now> }` to record the explicit onboarding pass.
 - "Done" → display "Settings unchanged." and exit
 
@@ -1180,6 +1181,74 @@ The selective-edit pass through Batch 9 MUST respect the §1b dispatch — it do
 
 ---
 
+## 3i. Present Settings (Batch 10: Collaboration Catch-Up)
+
+The **collaboration catch-up** surfaces show on every interactive (TTY) `/apt`
+call: a **Welcome-Back Summary** (your most-recently-active task + next step,
+always-on, local-only) and a **Team-Change Digest** (the PRs teammates merged
+to main since you last pulled — gated to `share.visibility` `team`/`oss`).
+Written to `.aperant/config.json.collaboration`.
+
+```
+AskUserQuestion([
+  {
+    question: "Show the Welcome-Back Summary when you return after a break?",
+    header: "Welcome-Back",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "On your next /apt after the staleness window, surface where you left off — task, phase, next step. Local only." },
+      { label: "No", description: "Never show the welcome-back nudge." }
+    ]
+  },
+  {
+    question: "How many hours away before the Welcome-Back Summary fires?",
+    header: "Threshold (hours)",
+    multiSelect: false,
+    options: [
+      { label: "16 (Recommended)", description: "Roughly 'since yesterday' — fires after an overnight gap." },
+      { label: "8", description: "Fires after a long lunch / half-day gap." },
+      { label: "24", description: "Once-a-day cadence." }
+    ]
+  },
+  {
+    question: "Show the Team-Change Digest (teammates' merged PRs since your last pull)?",
+    header: "Team Digest",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "Only computes when share.visibility is team/oss; reads local git history, never fetches." },
+      { label: "No", description: "Never show the digest, even in team/oss mode." }
+    ]
+  },
+  {
+    question: "Maximum PRs to list in the digest before '+N more on main'?",
+    header: "Digest Max Entries",
+    multiSelect: false,
+    options: [
+      { label: "7 (Recommended)", description: "Low-noise ceiling; the rest collapse into a '+N more' tail." },
+      { label: "5", description: "Tighter." },
+      { label: "12", description: "Roomier." }
+    ]
+  }
+])
+```
+
+For hosts without structured prompts, present the same four questions as
+numbered lists (Batch 5 style) and read single-index responses.
+
+### 3i.1 Review-Mode routing entry
+
+The "1b. Review Mode" routing table (§1b) includes "Collaboration" as a
+selectable edit target — jumping directly back into this Batch 10 picker.
+
+### 3i.2 Confirmation row
+
+Add a row to the Step 8 table:
+```
+| Collaboration | welcome-back {on/off} ({N}h) · team-digest {on/off} (max {M}) |
+```
+
+---
+
 ## 4. Map Answers to Config
 
 **AUDIT-001 — file-routing contract for per-device fields (UPDATED 0.8.1 for FRAMEWORK-RFC-001):** the
@@ -1295,6 +1364,12 @@ Note: task ids are slug-first since v0.6.6 — the date-format setting controls
 - "Sub-Agents" → `"sub-agents"`
 - "Sequential" → `"sequential"`
 
+**Collaboration Catch-Up (Batch 10):**
+- Welcome-Back "Yes" → `collaboration.welcome_back.enabled: true`, "No" → `false`
+- Threshold → `collaboration.welcome_back.threshold_hours: <8|16|24>`
+- Team Digest "Yes" → `collaboration.team_digest.enabled: true`, "No" → `false`
+- Digest Max Entries → `collaboration.team_digest.max_entries: <5|7|12>`
+
 ## 5. Write Config
 
 Write merged config to two files per AUDIT-001 routing (see Step 4 block):
@@ -1402,6 +1477,7 @@ Display:
 | Debate Mode          | {Auto / Agent Team / Sub-Agents / Sequential} |
 | Visibility           | {solo / team / oss} (overrides if any)        |
 | Changelog & Release Notes | dev: {Yes/No}; release-notes: {Yes/No} (audience, persona-filter) |
+| Collaboration        | welcome-back {on/off} ({N}h) · team-digest {on/off} (max {M}) |
 | Saved as Defaults    | {Yes/No}                     |
 
 Config saved to: .aperant/config.json

package/skills/apt-verify/SKILL.md

@@ -60,7 +60,7 @@ Before spawning any verifier subagent or running scoring against acceptance crit
 </locked_decisions>
 ```
 
-Verifiers apply this digest when interpreting "completeness" and "correctness" — if a decision explicitly deferred a behavior, its absence is NOT a verification failure.
+Verifiers apply this digest when interpreting "completeness" and "correctness" — if a decision explicitly deferred a behavior AND the deferred finding has severity below critical or major, its absence is NOT a verification failure. A deferred critical or major finding IS a Completeness gap — score accordingly and note it in the issues list.
 </decision_ledger_inject>
 
 <process>

package/skills/apt-verify-proof/SKILL.md

@@ -20,6 +20,7 @@ gates: []
 config_keys:
   - verification.open_report
   - verification.report_formats
+  - verification.provision_mcp
 ---
 
 # Proof Verification
@@ -104,13 +105,36 @@ disable the walk entirely (root-only behaviour, backwards compat).
 The `verification.runtimes[]` override stays the final escape hatch
 and is now usually unnecessary because the walk runs by default.
 
-### Bundled drivers (4)
+### Bundled drivers (5)
 
 - **browser** (priority=100, ga) — Next.js / vanilla web frontends.
 - **electron** (priority=90, ga) — Electron desktop apps.
+- **tauri** (priority=85, ga) — Tauri desktop apps.
 - **cli** (priority=60, ga) — headless CI, output-shape assertions.
 - **api** (priority=50, ga) — HTTP / JSON-API regression tests.
 
+### Install-time MCP provisioning (verification.provision_mcp)
+
+`apt-tools init` (and `/apt:update`, which routes through the same path)
+auto-provisions the MCP transport a driver needs into each SELECTED host
+CLI's config, so verify-proof works at the prompt with no manual MCP
+setup. It detects the project runtime and, per host:
+
+- **claude** → JSON-merges the server into the project-root `.mcp.json`
+  (`mcpServers.<id>`).
+- **codex** → upserts a `[mcp_servers.<id>]` table into the project-root
+  `.codex/config.toml`.
+
+Electron and Tauri projects get the matching MCP server; web frontends
+get the browser driver's declared `agent-browser` skill copied into the
+host skill dir (`.claude/skills/` / `.agents/skills/`) — its `agent-browser`
+CLI is a documented one-time prereq, the same class as the
+`electron-mcp-server` / `tauri-plugin-mcp-server` npm packages (see each
+driver's README). All writes are **TOFU/non-clobbering**: a pre-existing
+server id, config table, or skill file is never overwritten. Opt out with
+`verification.provision_mcp: false` (default `true`) — then init/update
+writes no host MCP config and no skill.
+
 ### Driver authors
 
 Third-party driver authors should run `apt-tools driver doctor .` before

package/src/cli/commands/catch-up.mjs

@@ -0,0 +1,67 @@
+/**
+ * commands/catch-up.mjs — read-only re-view of the combined catch-up panel
+ * (LD-13). Backs the `/apt:catch-up` skill.
+ *
+ * Recompute-only contract: this command computes the SAME panel the
+ * interactive route call would show (Welcome-Back + gated Team-Change Digest)
+ * against the CURRENT Last-Seen Marker, but it NEVER advances the marker. A
+ * user who dismissed the auto-on-apt display can re-summon it without
+ * disturbing their baseline. Distinct from /apt:resume (full context restore).
+ */
+
+import { resolve } from 'node:path'
+import { loadProjectConfig } from '../config/load.mjs'
+import { resolveSharePolicy } from '../config/share-policy.mjs'
+import { computeCatchUpPanel } from '../coordination/catch-up.mjs'
+import { createCoordinationStore } from '../coordination/store.mjs'
+import { resolveLocalDefaultBranch } from '../git/default-branch.mjs'
+import { err, ok } from '../util/result.mjs'
+
+/**
+ * @param {string} projectDir
+ * @returns {{ envelope: object, exitCode: number }}
+ */
+export function cmdCatchUp(projectDir) {
+	if (!projectDir) return err('Usage: apt-tools catch-up <project-dir>')
+	const targetDir = resolve(projectDir)
+
+	// Setup mirrors computeCatchUpForRoute in commands/route.mjs (advances marker).
+	const config = loadProjectConfig(targetDir)
+	if (!config) {
+		return ok({
+			status: 'ok',
+			command: 'catch-up',
+			catch_up: null,
+			reason: 'No .aperant/config.json — nothing to catch up on',
+		})
+	}
+
+	const store = createCoordinationStore(targetDir)
+	const marker = store.readLastSeen()
+	const td = config?.collaboration?.team_digest
+	const vis = resolveSharePolicy(config).visibility
+	const needsDigest = td?.enabled !== false && (vis === 'team' || vis === 'oss')
+	const defaultBranch = needsDigest ? resolveLocalDefaultBranch(targetDir) : null
+
+	let catch_up = null
+	try {
+		catch_up = computeCatchUpPanel(targetDir, {
+			config,
+			now: Date.now(),
+			marker,
+			defaultBranch,
+		})
+	} catch (e) {
+		console.warn('[apt] catch-up:', e?.message ?? e)
+		catch_up = null
+	}
+
+	// NOTE: recompute-only — we deliberately do NOT call store.advanceLastSeen.
+	// The marker baseline is owned by the interactive route path (route.mjs).
+	return ok({
+		status: 'ok',
+		command: 'catch-up',
+		catch_up,
+		reason: catch_up ? 'Catch-up panel recomputed' : 'Nothing new since your last visit',
+	})
+}

package/src/cli/commands/init.mjs

@@ -32,6 +32,7 @@ import { deriveSidecar } from '../bootstrap/product-context-sidecar.mjs'
 import { assertConfigWriteAllowed } from '../config/guard.mjs'
 import {
 	AUDIT_001_LOCAL_FIELDS,
+	loadMergedProjectConfig,
 	migrateDeferredFieldsToLocalConfig,
 	writeLocalConfigField,
 } from '../config/load.mjs'
@@ -42,6 +43,7 @@ import { detectPublicRemote } from '../git/remote.mjs'
 import { detectArchetype } from '../install/archetype.mjs'
 import { installKernel } from '../install/install-kernel.mjs'
 import { MANIFEST_FILENAME } from '../install/manifest.mjs'
+import { provisionMcpConfig } from '../install/mcp-provision.mjs'
 import {
 	discoverCanonicalFiles,
 	runInstall,
@@ -1304,6 +1306,23 @@ export async function cmdInit(projectDir, extraArgs = []) {
 		if (envelope?.__earlyExit) {
 			return envelope.__earlyExit
 		}
+
+		// Auto-provision host MCP-server config + the agent-browser skill for
+		// the detected runtime (C38). Runs on BOTH the fresh install AND the
+		// no-drift /apt:update upgrade path (both reach finishInit). finishInit
+		// has already written .aperant/config.json from the template, so the
+		// merged config carries verification.provision_mcp (default true) — the
+		// opt-out gate. TOFU/non-clobbering; never throws.
+		const mergedConfig = loadMergedProjectConfig(installTarget)
+		const mcpProvision = provisionMcpConfig({
+			targetDir: installTarget,
+			selectedRuntimes: effectiveAnswers.runtimes,
+			config: mergedConfig,
+			frameworkRoot: canonicalRoot,
+			version,
+		})
+		envelope.mcp_provision = mcpProvision
+
 		if (interactiveTty) {
 			await renderOutro(effectiveAnswers, results, version, kernelResult)
 			// TTY mode: envelope was persisted to disk + suppressed from stdout

package/src/cli/commands/pr-review.mjs

@@ -727,17 +727,30 @@ function parseGhPrView(raw) {
  * the viewer's personal handle (e.g. `AndyMik90`). They never match, which
  * previously caused every same-repo, owned PR to be mis-classified as
  * `external` and silently disabled auto-fix. The third arg `baseRepoOwner`
- * is the source of truth for "is this a fork PR?". `viewerLogin` is kept
- * only for backward-compatible signal reporting.
+ * is the source of truth for "is this a fork PR?".
+ *
+ * IMPORTANT (G44): "owned" means "a PR I authored," NOT "a branch in a repo I
+ * can push to." The owned test is strictly `gh.author.login === viewerLogin`
+ * — author IDENTITY, not `authorAssociation`. Previously a same-repo PR with
+ * `authorAssociation ∈ {OWNER, MEMBER, COLLABORATOR}` was classified `owned`,
+ * which meant every teammate's same-repo PR triggered the auto-fix-and-push
+ * pipeline on their branch. Now `authorAssociation` is retained only in the
+ * signal for human-readable tracing; it no longer gates the decision. The
+ * "is this mine" comparand is `gh.author?.login`, never `headRepoOwner`
+ * (comparing headRepoOwner to viewerLogin was the H1 bug — it never matches
+ * on an org-owned repo). Fork detection and author identity are independent:
+ * fork detection answers "did this come from a fork?"; author identity
+ * answers "did I write it?".
  *
  * @param {Record<string, any> | null | undefined} gh    parsed `gh pr view` JSON (may have `authorAssociation` grafted in by the REST-fetch path)
- * @param {string | null | undefined} viewerLogin        personal login from `gh api user` (fallback comparand for fork detection)
- * @param {string | null | undefined} [baseRepoOwner]    the org/user that owns the repo the PR targets (preferred comparand)
+ * @param {string | null | undefined} viewerLogin        personal login from `gh api user` (compared to `gh.author.login` for the owned test)
+ * @param {string | null | undefined} [baseRepoOwner]    the org/user that owns the repo the PR targets (fork-detection comparand)
  * @returns {{ authorship_mode: 'owned' | 'external' | 'unknown', authorship_signal: string }}
  */
 export function decideAuthorshipFromGh(gh, viewerLogin, baseRepoOwner = null) {
 	if (!gh) return { authorship_mode: 'unknown', authorship_signal: 'gh_payload_missing' }
 	const association = gh.authorAssociation ?? gh.author?.association ?? null
+	const author = gh.author?.login ?? null
 	const headRepoOwner =
 		gh.headRepository?.owner?.login ??
 		gh.headRepositoryOwner?.login ??
@@ -745,28 +758,36 @@ export function decideAuthorshipFromGh(gh, viewerLogin, baseRepoOwner = null) {
 		null
 	// Prefer baseRepoOwner when supplied; fall back to viewerLogin only for
 	// older callers that haven't been updated yet (e.g. legacy tests). The
-	// fallback preserves prior behavior for the personal-repo case.
+	// fallback preserves prior fork-detection behavior for the personal-repo
+	// case.
 	const compareOwner = baseRepoOwner ?? viewerLogin
 	const isFork = headRepoOwner && compareOwner && headRepoOwner !== compareOwner
 
-	const ownerLike = ['OWNER', 'MEMBER', 'COLLABORATOR']
 	const externalLike = ['NONE', 'CONTRIBUTOR', 'FIRST_TIME_CONTRIBUTOR', 'FIRST_TIMER']
 
-	if (!isFork && association && ownerLike.includes(association)) {
+	// G44: owned ⟺ (not a fork) AND the PR was authored by the running viewer.
+	if (!isFork && author && viewerLogin && author === viewerLogin) {
 		return {
 			authorship_mode: 'owned',
-			authorship_signal: `authorAssociation=${association}, same-repo branch (head=${headRepoOwner ?? '?'}, base=${compareOwner ?? '?'})`,
+			authorship_signal: `authored-by-viewer (author=${author}, viewer=${viewerLogin}), same-repo branch (head=${headRepoOwner ?? '?'}, base=${compareOwner ?? '?'}), authorAssociation=${association ?? 'null'}`,
 		}
 	}
-	if (isFork || (association && externalLike.includes(association))) {
+	// Forks, external-like associations, AND non-fork PRs authored by someone
+	// other than the viewer (a teammate's same-repo PR — the G44 case) all
+	// resolve to external (comment-only).
+	if (
+		isFork ||
+		(association && externalLike.includes(association)) ||
+		(!isFork && author && viewerLogin && author !== viewerLogin)
+	) {
 		return {
 			authorship_mode: 'external',
-			authorship_signal: `authorAssociation=${association}, fork=${Boolean(isFork)} (head=${headRepoOwner ?? '?'}, base=${compareOwner ?? '?'})`,
+			authorship_signal: `authorAssociation=${association ?? 'null'}, fork=${Boolean(isFork)}, author=${author ?? '?'}, viewer=${viewerLogin ?? '?'} (head=${headRepoOwner ?? '?'}, base=${compareOwner ?? '?'})`,
 		}
 	}
 	return {
 		authorship_mode: 'unknown',
-		authorship_signal: `authorAssociation=${association ?? 'null'}, fork=${Boolean(isFork)}`,
+		authorship_signal: `authorAssociation=${association ?? 'null'}, fork=${Boolean(isFork)}, author=${author ?? 'null'}`,
 	}
 }