@erclx/canon 5.70.0 → 5.72.0

package/src/feedback/github.ts

@@ -2,34 +2,73 @@ import { execa } from 'execa'
 import { gitEnv } from '@/git/env'
 import { PROJECT_ROOT } from '@/roots/project'
 import {
+  buildCommentArgs,
   buildIssueArgs,
+  buildIssueReadArgs,
   failureDetail,
+  parseIssueRead,
   type CreateIssueOptions,
   type CreateIssueResult,
+  type IssueFailure,
+  type IssueRead,
 } from '@/feedback/github-format'
 
 const GH_TIMEOUT_MS = 30_000
 
-export async function createGithubIssue(
-  opts: CreateIssueOptions,
-): Promise<CreateIssueResult> {
+/**
+ * Runs `gh` and returns its trimmed stdout, or the failure the operator reads.
+ * See src/worktrees/reclaim.ts for why gh needs the stripped environment.
+ */
+async function runGh(
+  args: string[],
+): Promise<{ ok: true; stdout: string } | IssueFailure> {
   if (Bun.which('gh') === null) return { ok: false, reason: 'missing-binary' }
   try {
-    // See src/worktrees/reclaim.ts for why gh needs the stripped environment.
-    const result = await execa('gh', buildIssueArgs(opts), {
+    const result = await execa('gh', args, {
       cwd: PROJECT_ROOT,
       timeout: GH_TIMEOUT_MS,
       env: gitEnv(),
       extendEnv: false,
     })
-    const url = result.stdout.trim()
-    if (url) return { ok: true, url }
-    return {
-      ok: false,
-      reason: 'command-failed',
-      detail: 'gh exited zero and printed no issue URL',
-    }
+    return { ok: true, stdout: result.stdout.trim() }
   } catch (error) {
     return { ok: false, reason: 'command-failed', detail: failureDetail(error) }
   }
 }
+
+async function runForUrl(
+  args: string[],
+  emptyDetail: string,
+): Promise<CreateIssueResult> {
+  const result = await runGh(args)
+  if (!result.ok) return result
+  if (result.stdout) return { ok: true, url: result.stdout }
+  return { ok: false, reason: 'command-failed', detail: emptyDetail }
+}
+
+export function createGithubIssue(
+  opts: CreateIssueOptions,
+): Promise<CreateIssueResult> {
+  return runForUrl(
+    buildIssueArgs(opts),
+    'gh exited zero and printed no issue URL',
+  )
+}
+
+export async function readFeedbackIssue(
+  issue: number,
+): Promise<IssueRead | IssueFailure> {
+  const result = await runGh(buildIssueReadArgs(issue))
+  if (!result.ok) return result
+  return parseIssueRead(result.stdout)
+}
+
+export function postIssueComment(
+  issue: number,
+  body: string,
+): Promise<CreateIssueResult> {
+  return runForUrl(
+    buildCommentArgs(issue, body),
+    'gh exited zero and printed no comment URL',
+  )
+}

package/src/markdown/colons.ts

@@ -22,8 +22,14 @@ const QUOTE_MARKER = /^(?:\s*>\s?)+/
 /** A colon followed by whitespace and more text, ruling out `10:30` and a scheme. */
 const COLON = /:(?=\s+\S)/g
 
+/** A colon followed by whitespace, which a masked code span leaves behind. */
+const LABEL_COLON = /:\s/
+
 const BOLD_LABEL = /^(\*\*|__)[^*_]+\1$/
 
+/** What may stand in a lead once its code spans and links are masked. */
+const CONNECTIVE = /\b(?:and|or|to)\b|,/g
+
 /** Blanks a span while holding its width, so a column stays where it was. */
 function blank(match: string): string {
   return ' '.repeat(match.length)
@@ -32,14 +38,74 @@ function blank(match: string): string {
 /**
  * Whether the text before a line's first colon is a label rather than a
  * clause: the lead of a list item, or a prefix that is only emphasis and a
- * masked code span.
+ * masked code span. A list item's lead also reads as a label at any length
+ * when only code spans, links, commas, and `and`, `or`, or `to` stand in it,
+ * which is a file entry naming several paths.
  */
 function isLabel(prefix: string, listItem: boolean): boolean {
   if (BOLD_LABEL.test(prefix.trim())) return true
 
   const words = prefix.replace(/[*_]/g, ' ').trim()
   if (words === '') return true
-  return listItem && words.split(/\s+/).length <= 4
+  if (!listItem) return false
+  if (words.replace(CONNECTIVE, ' ').trim() === '') return true
+  return words.split(/\s+/).length <= 4
+}
+
+interface Entry {
+  readonly line: BodyLine
+  readonly masked: string
+  readonly start: number
+  /** Width of the quote marker and the item's own leading whitespace. */
+  readonly indent: number
+  readonly quote: string
+  readonly isItem: boolean
+  /** Matches at or past the content start, the only ones a line can report. */
+  readonly colons: readonly RegExpExecArray[]
+  /** A colon stands past the content start, even with only a masked span after it. */
+  readonly labelColon: boolean
+  /** Items sharing one list at one indent, shared by reference. */
+  group?: Entry[]
+}
+
+/**
+ * Collects consecutive items at one indent into a list. A blank line, a
+ * heading, or a change of quote depth ends every open list, and a deeper child
+ * neither joins its parent's list nor ends it.
+ */
+function groupItems(entries: readonly Entry[]): void {
+  const open = new Map<number, Entry[]>()
+  let quote = ''
+
+  for (const entry of entries) {
+    if (entry.line.fenced) continue
+
+    const empty = entry.masked.slice(entry.quote.length).trim() === ''
+    if (entry.quote !== quote || empty || HEADING.test(entry.line.text)) {
+      open.clear()
+    }
+    quote = entry.quote
+    if (!entry.isItem) continue
+
+    for (const level of open.keys()) {
+      if (level > entry.indent) open.delete(level)
+    }
+
+    const group = open.get(entry.indent) ?? []
+    open.set(entry.indent, group)
+    group.push(entry)
+    entry.group = group
+  }
+}
+
+/** Whether the item sits in a list of two or more where every item has a colon. */
+function uniform(entry: Entry): boolean {
+  const group = entry.group
+  return (
+    group !== undefined &&
+    group.length >= 2 &&
+    group.every((item) => item.labelColon)
+  )
 }
 
 /**
@@ -47,30 +113,50 @@ function isLabel(prefix: string, listItem: boolean): boolean {
  *
  * A heading, a table row, a fence, a code span, a link, and a line-final colon
  * are left alone, and so is the first colon of a list item or of a line opening
- * on a bold or code label. The measure is advisory, because a colon is
- * sometimes right and the corpus count shows a gate would be a sweep nobody
- * asked for.
+ * on a bold or code label, and of every item in a list where each one carries a
+ * colon. The measure is advisory, because a colon is sometimes right and the
+ * corpus count shows a gate would be a sweep nobody asked for.
  */
 export function findColons(lines: readonly BodyLine[]): ColonFinding[] {
-  const found: ColonFinding[] = []
-
-  for (const line of lines) {
-    if (line.fenced || HEADING.test(line.text) || TABLE_ROW.test(line.text)) {
-      continue
-    }
-
+  const entries: Entry[] = lines.map((line) => {
     const masked = maskDisplayed(line.text.replace(LINK, blank))
     const quote = QUOTE_MARKER.exec(masked)?.[0] ?? ''
     const marker = LIST_MARKER.exec(masked.slice(quote.length))?.[0] ?? ''
     const start = quote.length + marker.length
-    let labelled = false
+    const skipped =
+      line.fenced || HEADING.test(line.text) || TABLE_ROW.test(line.text)
+
+    return {
+      line,
+      masked,
+      start,
+      indent: quote.length + marker.length - marker.trimStart().length,
+      quote: quote.replace(/\s/g, ''),
+      isItem: !skipped && marker !== '',
+      labelColon: !skipped && LABEL_COLON.test(masked.slice(start)),
+      colons: skipped
+        ? []
+        : [...masked.matchAll(COLON)].filter((match) => match.index >= start),
+    }
+  })
+
+  groupItems(entries)
 
-    for (const match of masked.matchAll(COLON)) {
-      if (match.index < start) continue
+  const found: ColonFinding[] = []
+
+  for (const entry of entries) {
+    const { line, masked, start } = entry
+    let labelled = false
 
+    for (const match of entry.colons) {
       if (!labelled) {
         labelled = true
-        if (isLabel(masked.slice(start, match.index), marker !== '')) continue
+        if (
+          isLabel(masked.slice(start, match.index), entry.isItem) ||
+          (entry.isItem && uniform(entry))
+        ) {
+          continue
+        }
       }
 
       found.push({

package/src/pr/carry.ts

@@ -0,0 +1,64 @@
+import { DESIGN_FOLDER, isEvidencePath } from '@/pr/evidence'
+import type { ChangedRead } from '@/pr/lift'
+import { DEFAULT_PAINTED } from '@/pr/painted'
+import { coversHead } from '@/pr/review-scope'
+
+/**
+ * The globs no checklist box can observe: tests, stories, snapshots, and
+ * markdown where a project keeps docs. The rule lists what is inert rather than
+ * what is driven, so a kind nobody listed, such as a `.json` data file, fails
+ * closed. Markdown elsewhere, such as an Astro page or content entry, renders,
+ * so it is driven like `.mdx`.
+ */
+export const DEFAULT_INERT: readonly string[] = [
+  ...DEFAULT_PAINTED.unpainted,
+  '*.md',
+  'canon/**/*.md',
+  '.claude/**/*.md',
+  '.github/**/*.md',
+  'docs/**/*.md',
+]
+
+/**
+ * An evidence capture and a design record are inert too, the two paths
+ * `readUncaptured` skips, since a recapture or a design note changes no
+ * behavior a box drives.
+ */
+export function isInert(path: string): boolean {
+  return (
+    isEvidencePath(path) ||
+    path.startsWith(DESIGN_FOLDER) ||
+    DEFAULT_INERT.some((glob) => new Bun.Glob(glob).match(path))
+  )
+}
+
+/** Whether a UI verdict at one commit still holds at a later one. */
+export type Carry =
+  | { readonly kind: 'covered' }
+  | { readonly kind: 'carried'; readonly carriedFrom: string }
+  | { readonly kind: 'moved'; readonly drivenPaths: readonly string[] }
+  | { readonly kind: 'not-ancestor' }
+  | { readonly kind: 'failed' }
+
+/**
+ * Carries a verdict driven at `from` to `to` only across a gap that changed
+ * nothing a box drives. A box drives behavior, which lives in any source file
+ * and not only in a painted one, so every path outside the inert set moves the
+ * verdict. A `from` that `to` does not descend from never carries.
+ */
+export async function readCarry(
+  readChanged: (from: string, to: string) => Promise<ChangedRead | undefined>,
+  from: string,
+  to: string,
+): Promise<Carry> {
+  if (coversHead(from, to)) return { kind: 'covered' }
+
+  const changed = await readChanged(from, to)
+  if (changed === undefined) return { kind: 'failed' }
+  if (!changed.isAncestor) return { kind: 'not-ancestor' }
+
+  const drivenPaths = changed.paths.filter((path) => !isInert(path))
+  return drivenPaths.length > 0
+    ? { kind: 'moved', drivenPaths }
+    : { kind: 'carried', carriedFrom: from }
+}

package/src/pr/evidence.ts

@@ -607,7 +607,7 @@ export function readOwed(input: OwedInput): OwedStep[] {
  * Design references are redrawn rather than captured, so recapturing them
  * neither owes nor stands in for an evidence capture.
  */
-const DESIGN_FOLDER = 'canon/design/'
+export const DESIGN_FOLDER = 'canon/design/'
 
 /**
  * The painted paths a pull request changed while no evidence image did, in a

package/src/pr/lift.ts

@@ -6,6 +6,7 @@ import {
   resolveUiScope,
   type UiCounts,
 } from '@/pr/review-scope'
+import { readCarry } from '@/pr/carry'
 import { DEFAULT_PAINTED, isPainted, type PaintedPatterns } from '@/pr/painted'
 
 /** How long `--wait` holds for a pending CI run, in seconds, when none is named. */
@@ -49,6 +50,8 @@ export interface GateResult {
   readonly carriedFrom?: string
   /** The painted paths that kept a UI close from carrying forward. */
   readonly paintedPaths?: readonly string[]
+  /** Every path a box can observe that kept a UI close from carrying forward. */
+  readonly drivenPaths?: readonly string[]
 }
 
 /** How an earlier commit sits against the head, and what changed since. */
@@ -125,6 +128,7 @@ export interface LiftRecord {
   readonly failed?: LiftRefusal
   readonly carriedFrom?: string
   readonly paintedPaths?: readonly string[]
+  readonly drivenPaths?: readonly string[]
   readonly isLifted: boolean
   /** Whether the caller can treat the pull request as ready afterwards. */
   readonly isOk: boolean
@@ -164,11 +168,13 @@ export function reviewGate(
 function carried(gates: readonly GateResult[]): {
   carriedFrom?: string
   paintedPaths?: readonly string[]
+  drivenPaths?: readonly string[]
 } {
   const ui = gates.find((gate) => gate.gate === 'ui')
   return {
     ...(ui?.carriedFrom !== undefined && { carriedFrom: ui.carriedFrom }),
     ...(ui?.paintedPaths !== undefined && { paintedPaths: ui.paintedPaths }),
+    ...(ui?.drivenPaths !== undefined && { drivenPaths: ui.drivenPaths }),
   }
 }
 
@@ -189,10 +195,11 @@ function droveNothing(counts: UiCounts | undefined): boolean {
 /**
  * Binds only where the evidence record carries a checklist to drive.
  *
- * A close behind the head still holds when it is an ancestor of the head and
- * no painted path changed since, since a push that paints nothing leaves the
- * checklist the reviewer drove as true as it was. A close that is not an
- * ancestor, which a force-push or a rebase leaves, never carries.
+ * A close behind the head still holds across the gap `readCarry` carries,
+ * one changing no path a box can observe. A box drives behavior, so a push to
+ * a non-painted source file moves the verdict too, and `drivenPaths` names
+ * every such path while `paintedPaths` keeps the painted subset. A close that
+ * is not an ancestor, which a force-push or a rebase leaves, never carries.
  */
 export async function uiGate(
   api: Pick<LiftApi, 'readChanged'>,
@@ -211,17 +218,27 @@ export async function uiGate(
   // Ahead of the head test so a close carried across commits is refused too.
   // A verdict whose count line did not parse reads as unchecked and goes on.
   if (droveNothing(scope.counts)) return fail('ui', 'ui-undriven')
-  if (coversHead(scope.commit, head)) return pass('ui')
 
-  const changed = await api.readChanged(scope.commit, head)
-  if (changed === undefined) return fail('ui', 'gh-failed')
-  if (!changed.isAncestor) return fail('ui', 'ui-behind')
+  const carry = await readCarry(
+    (from, to) => api.readChanged(from, to),
+    scope.commit,
+    head,
+  )
+  if (carry.kind === 'covered') return pass('ui')
+  if (carry.kind === 'failed') return fail('ui', 'gh-failed')
+  if (carry.kind === 'not-ancestor') return fail('ui', 'ui-behind')
+  if (carry.kind === 'carried') {
+    return { ...pass('ui'), carriedFrom: carry.carriedFrom }
+  }
 
-  const paintedPaths = changed.paths.filter((path) => isPainted(path, painted))
-  if (paintedPaths.length > 0) {
-    return { ...fail('ui', 'ui-behind'), paintedPaths }
+  const paintedPaths = carry.drivenPaths.filter((path) =>
+    isPainted(path, painted),
+  )
+  return {
+    ...fail('ui', 'ui-behind'),
+    ...(paintedPaths.length > 0 && { paintedPaths }),
+    drivenPaths: carry.drivenPaths,
   }
-  return { ...pass('ui'), carriedFrom: scope.commit }
 }
 
 function standingGate(standing: Standing): GateResult {

package/src/pr/review-state.ts

@@ -47,6 +47,7 @@ export interface UiState extends UiScope, FamilyState {
   readonly isBound: boolean
   readonly carriedFrom?: string
   readonly paintedPaths?: readonly string[]
+  readonly drivenPaths?: readonly string[]
 }
 
 export interface ReviewStateRecord {
@@ -119,6 +120,7 @@ async function readAt(
         isBound: hasChecklist,
         ...(ui.carriedFrom !== undefined && { carriedFrom: ui.carriedFrom }),
         ...(ui.paintedPaths !== undefined && { paintedPaths: ui.paintedPaths }),
+        ...(ui.drivenPaths !== undefined && { drivenPaths: ui.drivenPaths }),
       },
     },
   }

package/src/tasks/archive.ts

@@ -325,6 +325,57 @@ export function readPendingBranches(text: string): readonly string[] {
     .filter((entry) => entry.length > 0)
 }
 
+/**
+ * A local session's full sessionId, or the `session_` id a cloud create reads
+ * out. Only the full form reaches `canon sessions export`, so a short prefix is
+ * refused rather than written.
+ */
+const SESSION_ID_SOURCE =
+  '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|session_[A-Za-z0-9]+'
+
+export const SESSION_ID_PATTERN = new RegExp(`^(?:${SESSION_ID_SOURCE})$`)
+
+export const SESSIONS_PREFIX = 'Sessions:'
+
+/**
+ * One entry is a name and its parenthesized id, and the parse keys on that
+ * trailing id, so a roster name carrying a comma or its own parentheses still
+ * reads as one entry.
+ */
+const SESSION_ENTRY_PATTERN = new RegExp(
+  `(.+?) \\((${SESSION_ID_SOURCE})\\)(?:, |$)`,
+  'y',
+)
+
+export interface SessionEntry {
+  readonly name: string
+  readonly sessionId: string
+}
+
+/**
+ * Reads the `Sessions:` line `canon tasks session` writes. A line that does not
+ * parse whole reads as naming none, the way `readPullRequest` reads a line
+ * carrying anything besides its list.
+ */
+export function readSessions(text: string): readonly SessionEntry[] {
+  const line = text
+    .split('\n')
+    .find((entry) => entry.startsWith(SESSIONS_PREFIX))
+  if (line === undefined) return []
+
+  const body = line.slice(SESSIONS_PREFIX.length).trim()
+  const entries: SessionEntry[] = []
+  const pattern = new RegExp(SESSION_ENTRY_PATTERN)
+
+  while (pattern.lastIndex < body.length) {
+    const match = pattern.exec(body)
+    if (!match) return []
+    entries.push({ name: match[1], sessionId: match[2] })
+  }
+
+  return entries
+}
+
 /** A markdown link on a `Plan:` line, its target captured. */
 const PLAN_LINK_PATTERN = /\[[^\]]*\]\(([^)]+)\)/g
 
@@ -514,7 +565,8 @@ export function declineLine(reason: string, by: string, date: string): string {
 /**
  * Lines a `Declined:` line anchors after, mirroring `record.ts`'s
  * `ORIGIN_PREFIXES` with `Pull request:` folded in, since a decline can follow
- * a pull request that never merged.
+ * a pull request that never merged. `Sessions:` joins them, since the sessions
+ * that worked a task sit above whatever ended it.
  */
 const DECLINE_ANCHOR_PREFIXES = [
   'Plan:',
@@ -522,6 +574,7 @@ const DECLINE_ANCHOR_PREFIXES = [
   'Intake:',
   'Issue:',
   'Pull request:',
+  SESSIONS_PREFIX,
 ] as const
 
 function lastAnchorLine(lines: readonly string[]): number | undefined {

package/src/tasks/record.ts

@@ -15,6 +15,9 @@ import {
   readPendingBranches,
   readPlanTargets,
   readPullRequest,
+  readSessions,
+  SESSION_ID_PATTERN,
+  SESSIONS_PREFIX,
   tasksDir,
 } from '@/tasks/archive'
 import { checkWaiting, type LinkPromotion, promoteOnLink } from '@/tasks/board'
@@ -34,6 +37,9 @@ const ORIGIN_PREFIXES = ['Plan:', 'Groundwork:', 'Intake:', 'Issue:'] as const
  *
  * `several-plans` answers a `Plan:` line that already links more than one plan.
  * `plan-link` cannot know which link to drop, so it writes nothing.
+ *
+ * `no-name` answers a session id the roster no longer lists, called with no
+ * name, since an id written alone reads as nobody to the next reader.
  */
 export const RECORD_REFUSALS = [
   'no-board',
@@ -44,6 +50,7 @@ export const RECORD_REFUSALS = [
   'no-plan',
   'several-plans',
   'bad-input',
+  'no-name',
 ] as const
 
 export type RecordRefusal = (typeof RECORD_REFUSALS)[number]
@@ -88,6 +95,18 @@ export interface PlanRecorded {
 
 export type PlanOutcome = PlanRecorded | RecordRefused
 
+export interface SessionRecorded {
+  readonly ok: true
+  readonly stem: string
+  readonly path: string
+  readonly sessionId: string
+  /** The name the line carries for the id, which a repeat call never renames. */
+  readonly name: string
+  readonly action: Exclude<LineAction, 'corrected'>
+}
+
+export type SessionOutcome = SessionRecorded | RecordRefused
+
 export interface OutcomesClosed {
   readonly ok: true
   readonly stem: string
@@ -228,6 +247,47 @@ export function clearPendingBranch(
   return { text: lines.join('\n'), changed: true }
 }
 
+/**
+ * Names a session on the `Sessions:` line, keyed on the id, so a dispatcher
+ * and `git-pr` recording the same worker write it once. The line sits below
+ * every other line a task carries above its outcomes, so a pull request
+ * recorded later lands above it.
+ */
+export function writeSessionsLine(
+  text: string,
+  name: string,
+  sessionId: string,
+): { readonly text: string; readonly action: SessionRecorded['action'] } {
+  const entry = `${name} (${sessionId})`
+  const lines = text.split('\n')
+  const existing = lines.findIndex((line) => line.startsWith(SESSIONS_PREFIX))
+
+  if (existing !== -1) {
+    if (lines[existing].includes(`(${sessionId})`)) {
+      return { text, action: 'unchanged' }
+    }
+    lines[existing] = `${lines[existing].trimEnd()}, ${entry}`
+    return { text: lines.join('\n'), action: 'appended' }
+  }
+
+  const line = `${SESSIONS_PREFIX} ${entry}`
+  const anchor = lastOriginLine(lines, [
+    ...ORIGIN_PREFIXES,
+    'Pull request:',
+    PENDING_PREFIX,
+  ])
+  if (anchor !== undefined) {
+    lines.splice(anchor + 1, 0, line)
+    return { text: lines.join('\n'), action: 'added' }
+  }
+
+  const heading = lines.findIndex((entry) => entry.startsWith('# '))
+  if (heading === -1) return { text: `${line}\n${text}`, action: 'added' }
+
+  lines.splice(heading + 1, 0, '', line)
+  return { text: lines.join('\n'), action: 'added' }
+}
+
 export type PlanLineWrite =
   | {
       readonly ok: true
@@ -566,6 +626,64 @@ export async function recordPlan(
   }
 }
 
+/**
+ * Records a session that worked a task on its `Sessions:` line. The caller
+ * resolves `name` from the roster or takes it from `--name`, and an undefined
+ * name refuses rather than writing a bare id. The id is checked first, since a
+ * malformed one is a caller defect and every later check would hide it.
+ */
+export async function recordSession(
+  root: string,
+  selector: RecordSelector,
+  sessionId: string,
+  name: string | undefined,
+): Promise<SessionOutcome> {
+  if (!SESSION_ID_PATTERN.test(sessionId)) {
+    return refuse(
+      'bad-input',
+      `Not a full sessionId: ${sessionId}. Pass the whole id canon sessions list --json carries.`,
+      [sessionId],
+    )
+  }
+
+  if (name === undefined) {
+    return refuse(
+      'no-name',
+      `No live session carries ${sessionId}, so its name cannot be read. Pass --name.`,
+      [sessionId],
+    )
+  }
+
+  const trimmed = name.trim()
+  if (trimmed.length === 0 || /[\r\n]/.test(trimmed)) {
+    return refuse('bad-input', 'A session name is one non-empty line.', [name])
+  }
+
+  const opened = await openTask(root, selector)
+  if ('ok' in opened) return opened
+
+  const { stem, path } = opened
+  const written = writeSessionsLine(
+    await readFile(path, 'utf8'),
+    trimmed,
+    sessionId,
+  )
+  if (written.action !== 'unchanged') await writeFile(path, written.text)
+
+  const listed = readSessions(written.text).find(
+    (entry) => entry.sessionId === sessionId,
+  )
+
+  return {
+    ok: true,
+    stem,
+    path,
+    sessionId,
+    name: listed?.name ?? trimmed,
+    action: written.action,
+  }
+}
+
 /**
  * Marks the named outcomes `[x]` in place. `task-complete` runs this against a
  * board it can read and cannot edit from a linked worktree, and the positions