taskchef 7.13.0 → 7.14.1

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.13.0",
+  "version": "7.14.1",
   "description": "Dispatch work from a data-only workspace to visible Codex project tasks.",
   "author": {
     "name": "Favo Yang",

package/docs/spec.md

@@ -138,6 +138,13 @@ the final link, preserving the delegate skill's immediate-return contract.
    TaskChef MUST atomically close it as `interrupted` before appending the new
    working turn; the executor MUST NOT report semantic `failed` for recovery.
 
+Request and result summaries are the durable source for dashboard related-link
+projection; TaskChef does not scan full Codex transcripts. When known, an
+executor MUST preserve the selected repository as a canonical GitHub repository
+URL and issues or pull requests as canonical URLs. A result spanning both a
+managed child repository and its workspace/root repository MUST include both
+pull-request URLs. Executors MUST NOT guess unresolved repository identity.
+
 If native creation fails after recording, the dispatcher MUST call
 `report_state` with `failed`, null thread/turn IDs, and a bounded summary.
 A link failure MUST remain visible and retryable; the executor MUST report it
@@ -287,8 +294,8 @@ marker, or ineligible state fails.
 | `threadId` | Matching non-empty ID for a linked task; null only for creation failure. |
 | `turnId` | Current canonical Codex UUIDv7 for a linked MCP journey; null only for creation failure. Maximum 256 characters at the MCP boundary. |
 | `status` | `working`, `needs_input`, `completed`, or `failed`. |
-| `summary` | Omitted or null for `working`; required non-empty string of at most 2,000 characters otherwise. |
-| `requestSummary` | Concise current request of at most 1,000 characters for `working`; optional for backward compatibility and omitted for semantic states. |
+| `summary` | Omitted or null for `working`; required non-empty string of at most 2,000 characters otherwise. Known GitHub issues and pull requests use canonical URLs. |
+| `requestSummary` | Concise current request of at most 1,000 characters for `working`; optional for backward compatibility and omitted for semantic states. A known selected GitHub repository uses its canonical URL. |
 
 **Structured output:** `{ task: Task }`.
 

package/docs/workflows.md

@@ -120,6 +120,13 @@ The executor obtains the turn identity from an exact native read of its own
 linked task. `report_state` records live turn state as a paired request/result
 timeline.
 
+That timeline is also the durable GitHub-link source. A working request names a
+known selected repository with its canonical GitHub URL. A terminal result
+keeps full issue and pull-request URLs, including separate child-repository and
+workspace/root pull requests. The dashboard does not recover omitted links by
+scanning the native Codex transcript, and the executor does not guess an
+ambiguous repository.
+
 ```mermaid
 sequenceDiagram
   autonumber

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.13.0",
+  "version": "7.14.1",
   "description": "A non-blocking interactive dispatcher for visible Codex tasks.",
   "license": "MIT",
   "author": "Favo Yang",

package/skills/taskchef-executor/SKILL.md

@@ -35,6 +35,9 @@ Complete this lifecycle setup before substantive assignment work:
 4. Call TaskChef `report_state` with the marked task ID, self-linked thread ID,
    current turn ID, `status: working`, an omitted or null result summary, and a
    concise `requestSummary` describing this turn's assignment or follow-up.
+   When the turn targets a known GitHub repository, include its canonical
+   `https://github.com/<owner>/<repository>` URL so multi-repository projects
+   retain the selected repository instead of leaving TaskChef to guess.
 
 If the preceding TaskChef turn is still unfinished because its terminal report
 was lost, this newer valid working report atomically records that predecessor
@@ -71,6 +74,30 @@ and unnecessary personal data. Identical lifecycle retries are safe; never
 replace a same-turn report with different content or let an older turn
 overwrite newer state.
 
+### Preserve repository and delivery links
+
+Treat lifecycle summaries as the durable TaskChef timeline; the dashboard does
+not scan the full Codex transcript later. Preserve known GitHub context in that
+timeline with canonical links:
+
+- Use `https://github.com/<owner>/<repository>` when identifying the repository
+  selected for a turn. Derive it from established project or Git remote
+  evidence; never guess from a similarly named directory.
+- Use the full canonical issue or pull-request URL whenever one is known. Do
+  not shorten it to bare `#123` or `PR #123` in a multi-repository project.
+- Include every delivered pull request in the result summary. If work produces
+  both a child-repository pull request and a workspace/root pull request,
+  preserve both URLs and state which repository each belongs to.
+- Keep references specific to the text being reported. Do not copy unrelated
+  links from earlier turns merely to make them visible.
+- Never invent an issue, pull request, or repository link. If repository
+  identity is genuinely unresolved, describe that ambiguity without a link.
+
+For example, a working summary may say `Update dashboard projection in
+https://github.com/favoyang/taskchef`. A terminal summary may say `Shipped the
+child change in https://github.com/favoyang/taskchef/pull/78 and the workspace
+plan in https://github.com/favoyang/skills-workspace/pull/62`.
+
 ## Compatibility
 
 Existing delegated tasks may include the former inline ownership, linking, and

package/src/dashboard/app.js

@@ -16,6 +16,7 @@ import {
   turnPresentation,
 } from "./state.js";
 import { openTaskFromControl } from "./actions.js";
+import { githubReferenceSegments } from "./github-links.js";
 import { formatRelativeTime, RelativeTimeController, parsedTimestamp } from "./time.js";
 
 const state = {
@@ -43,6 +44,7 @@ const elements = {
   dialogInstruction: document.querySelector("#dialog-instruction"),
   dialogMetadata: document.querySelector("#dialog-metadata"),
   dialogProject: document.querySelector("#dialog-project"),
+  dialogRelatedLinks: document.querySelector("#dialog-related-links"),
   dialogResults: document.querySelector("#dialog-results"),
   dialogTitle: document.querySelector("#dialog-title"),
   dismissDashboardMessage: document.querySelector("#dismiss-dashboard-message"),
@@ -59,6 +61,58 @@ const elements = {
 };
 let notificationDescriptionSerial = 0;
 
+function githubLink(link, { compact = false } = {}) {
+  const anchor = document.createElement("a");
+  anchor.className = compact ? "github-link github-link-compact" : "github-link";
+  anchor.href = link.url;
+  anchor.target = "_blank";
+  anchor.rel = "noopener noreferrer";
+  anchor.textContent = link.label ?? link.text;
+  anchor.setAttribute(
+    "aria-label",
+    `${link.label ?? link.text} on GitHub (opens in a new tab)`,
+  );
+  anchor.addEventListener("click", (event) => event.stopPropagation());
+  return anchor;
+}
+
+function appendGitHubText(container, text, task) {
+  const children = githubReferenceSegments(text, {
+    projectRepositories: task.project?.githubRepos,
+    taskRepository: task.relatedGitHubRepository,
+  }).map((segment) => {
+    if (segment.kind === "text") return document.createTextNode(segment.text);
+    if (segment.kind === "link") return githubLink(segment);
+    const ambiguous = document.createElement("span");
+    ambiguous.className = "github-reference-ambiguous";
+    ambiguous.textContent = segment.text;
+    ambiguous.tabIndex = 0;
+    ambiguous.title = segment.reason;
+    ambiguous.setAttribute("aria-label", segment.reason);
+    return ambiguous;
+  });
+  container.replaceChildren(...children);
+}
+
+function relatedGitHubLinks(task, { compact = false } = {}) {
+  const links = task.relatedGitHubLinks ?? [];
+  const container = document.createElement("nav");
+  container.className = `github-links${compact ? " github-links-compact" : ""}`;
+  container.setAttribute("aria-label", `Related GitHub links for ${task.title}`);
+  const children = links.map((link) => githubLink(link, { compact }));
+  if (task.relatedGitHubLinksTruncated) {
+    const more = document.createElement("span");
+    more.className = "github-links-more";
+    more.textContent = "+ more";
+    more.title = "Additional related GitHub references are omitted from this bounded dashboard view.";
+    more.setAttribute("aria-label", more.title);
+    children.push(more);
+  }
+  container.hidden = children.length === 0;
+  container.replaceChildren(...children);
+  return container;
+}
+
 function timestampControl(value, { accessibleName, key, prefix = "" }) {
   if (!parsedTimestamp(value)) {
     const missing = document.createElement("span");
@@ -253,12 +307,16 @@ function turnTimeline(task) {
     requestLabel.textContent = "Request";
     const request = document.createElement("p");
     request.className = "preserve-lines";
-    request.textContent = turn.requestSummary ?? "Request not recorded by this TaskChef version.";
+    appendGitHubText(
+      request,
+      turn.requestSummary ?? "Request not recorded by this TaskChef version.",
+      task,
+    );
     const resultLabel = document.createElement("h4");
     resultLabel.textContent = "Result";
     const result = document.createElement("p");
     result.className = "preserve-lines";
-    result.textContent = presentation.summary;
+    appendGitHubText(result, presentation.summary, task);
     const turnMetadata = document.createElement("p");
     turnMetadata.className = "result-history-turn";
     turnMetadata.textContent = turn.turnId
@@ -281,6 +339,14 @@ function renderDialog(task) {
   state.selectedTask = detailedTask;
   elements.dialogProject.textContent = task.project.name;
   elements.dialogTitle.textContent = task.title;
+  elements.dialogRelatedLinks.replaceChildren(...relatedGitHubLinks(detailedTask).children);
+  elements.dialogRelatedLinks.setAttribute(
+    "aria-label",
+    `Related GitHub links for ${task.title}`,
+  );
+  elements.dialogRelatedLinks.hidden = (
+    (task.relatedGitHubLinks?.length ?? 0) === 0 && !task.relatedGitHubLinksTruncated
+  );
   elements.dialogResults.replaceChildren(...turnTimeline(detailedTask));
   elements.dialogInstruction.textContent = task.instruction;
   elements.copyThreadId.disabled = !task.threadId;
@@ -365,6 +431,7 @@ function taskCard(task) {
   result.className = "preserve-lines";
   result.textContent = latest.resultSummary;
   summary.replaceChildren(requestLabel, request, resultLabel, result);
+  const relatedLinks = relatedGitHubLinks(task, { compact: true });
   const time = timestampControl(
     task.meaningfulUpdatedAt ?? task.updatedAt ?? task.createdAt,
     {
@@ -383,7 +450,7 @@ function taskCard(task) {
     showMessage,
   }));
   footer.append(time, openTask);
-  article.append(heading, project, summary, footer);
+  article.append(heading, project, summary, relatedLinks, footer);
   return article;
 }
 

package/src/dashboard/github-links.js

@@ -0,0 +1,212 @@
+const GITHUB_REPOSITORY = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\/[A-Za-z0-9._-]+$/;
+const REFERENCE_PATTERN = /https?:\/\/(?:www\.)?github\.com\/([A-Za-z0-9](?:[A-Za-z0-9-]{0,38}))\/([A-Za-z0-9._-]+)\/(issues|pull)\/([1-9]\d*)(?![A-Za-z0-9_])|([A-Za-z0-9](?:[A-Za-z0-9-]{0,38}))\/([A-Za-z0-9._-]+)#([1-9]\d*)(?![A-Za-z0-9_])|#([1-9]\d*)(?![A-Za-z0-9_])|https?:\/\/(?:www\.)?github\.com\/([A-Za-z0-9](?:[A-Za-z0-9-]{0,38}))\/([A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9_-])?)\/?(?=$|[\s),.;:!?'"\]}>])/gi;
+export const MAX_RELATED_GITHUB_LINKS = 20;
+
+function canonicalRepository(owner, repository) {
+  return `${owner.toLowerCase()}/${repository.toLowerCase()}`;
+}
+
+function validRepositoryName(repository) {
+  return repository !== "." && repository !== "..";
+}
+
+export function normalizeGitHubRepository(value) {
+  if (typeof value !== "string") return null;
+  let candidate = value.trim();
+  const url = candidate.match(/^https?:\/\/(?:www\.)?github\.com\/([^/?#]+)\/([^/?#]+?)(?:\.git)?\/?$/i);
+  if (url) candidate = `${url[1]}/${url[2]}`;
+  if (!GITHUB_REPOSITORY.test(candidate)) return null;
+  const [owner, repository] = candidate.split("/");
+  if (!validRepositoryName(repository)) return null;
+  return canonicalRepository(owner, repository);
+}
+
+function rawReferences(text) {
+  const value = String(text ?? "");
+  const references = [];
+  for (const match of value.matchAll(REFERENCE_PATTERN)) {
+    const start = match.index;
+    const preceding = start > 0 ? value[start - 1] : "";
+    if (match[8] && /[\w&#/]/.test(preceding)) continue;
+    if ((match[5] || match[1] || match[9]) && /[\w/]/.test(preceding)) continue;
+
+    let owner = match[1] ?? match[5] ?? match[9] ?? null;
+    let repository = match[2] ?? match[6] ?? match[10] ?? null;
+    if (match[9]) repository = repository.replace(/\.git$/i, "");
+    const number = match[4] ?? match[7] ?? match[8] ?? null;
+    const pathType = match[3]?.toLowerCase();
+    const type = match[9]
+      ? "repository"
+      : pathType === "pull" ? "pull" : pathType === "issues" ? "issue" : "generic";
+    const explicit = Boolean(owner && repository);
+    if (explicit) {
+      if (!validRepositoryName(repository)) continue;
+      const normalized = canonicalRepository(owner, repository);
+      [owner, repository] = normalized.split("/");
+    }
+    references.push({
+      end: start + match[0].length,
+      explicit,
+      number,
+      owner,
+      repository,
+      start,
+      text: match[0],
+      type,
+    });
+  }
+  return references;
+}
+
+function uniqueExplicitRepository(references) {
+  const repositories = new Set(
+    references.filter(({ explicit }) => explicit).map(({ owner, repository }) => (
+      `${owner}/${repository}`
+    )),
+  );
+  return repositories.size === 1 ? [...repositories][0] : null;
+}
+
+function uniqueProjectRepository(projectRepositories) {
+  const repositories = new Set(
+    (projectRepositories ?? []).map(normalizeGitHubRepository).filter(Boolean),
+  );
+  return repositories.size === 1 ? [...repositories][0] : null;
+}
+
+function resolvedReference(reference, repositoryContext) {
+  const repository = reference.explicit
+    ? `${reference.owner}/${reference.repository}`
+    : repositoryContext;
+  if (!repository) return null;
+  const [owner, repositoryName] = repository.split("/");
+  if (reference.type === "repository") {
+    return {
+      kind: "link",
+      number: null,
+      owner,
+      repository: repositoryName,
+      text: reference.text,
+      type: reference.type,
+      url: `https://github.com/${owner}/${repositoryName}`,
+    };
+  }
+  const path = reference.type === "pull" ? "pull" : "issues";
+  return {
+    kind: "link",
+    number: reference.number,
+    owner,
+    repository: repositoryName,
+    text: reference.text,
+    type: reference.type,
+    url: `https://github.com/${owner}/${repositoryName}/${path}/${reference.number}`,
+  };
+}
+
+export function githubReferenceSegments(text, {
+  projectRepositories = [],
+  taskRepository = null,
+} = {}) {
+  const value = String(text ?? "");
+  const references = rawReferences(value);
+  const sourceRepository = uniqueExplicitRepository(references);
+  const repositoryContext = sourceRepository
+    ?? normalizeGitHubRepository(taskRepository)
+    ?? uniqueProjectRepository(projectRepositories);
+  const segments = [];
+  let offset = 0;
+  for (const reference of references) {
+    if (reference.start > offset) {
+      segments.push({ kind: "text", text: value.slice(offset, reference.start) });
+    }
+    const resolved = resolvedReference(reference, repositoryContext);
+    if (resolved) segments.push(resolved);
+    else {
+      segments.push({
+        kind: "ambiguous",
+        reason: `GitHub reference ${reference.text} is not linked because the repository is ambiguous.`,
+        text: reference.text,
+      });
+    }
+    offset = reference.end;
+  }
+  if (offset < value.length) segments.push({ kind: "text", text: value.slice(offset) });
+  return segments;
+}
+
+function taskTexts(task) {
+  const texts = [task.instruction];
+  for (const turn of task.turns ?? []) {
+    texts.push(turn.requestSummary, turn.result?.summary);
+  }
+  if (!(task.turns?.length > 0)) {
+    for (const result of task.results ?? []) texts.push(result.summary);
+    texts.push(task.summary);
+  }
+  return texts.filter((text) => typeof text === "string" && text.length > 0);
+}
+
+function relatedLinkLabel(link, includeRepository, includeOwner) {
+  if (link.type === "repository") return `${link.owner}/${link.repository}`;
+  const reference = link.type === "pull"
+    ? `PR #${link.number}`
+    : link.type === "issue"
+      ? `Issue #${link.number}`
+      : `#${link.number}`;
+  if (!includeRepository) return reference;
+  const repository = includeOwner ? `${link.owner}/${link.repository}` : link.repository;
+  return `${repository} ${reference}`;
+}
+
+export function taskGitHubProjection(task) {
+  const texts = taskTexts(task);
+  const explicitRepositories = new Set();
+  for (const text of texts) {
+    for (const reference of rawReferences(text)) {
+      if (reference.explicit) {
+        explicitRepositories.add(`${reference.owner}/${reference.repository}`);
+      }
+    }
+  }
+  const taskRepository = explicitRepositories.size === 1 ? [...explicitRepositories][0] : null;
+  const links = [];
+  const seen = new Set();
+  let truncated = false;
+  sourceLoop:
+  for (const text of texts) {
+    for (const segment of githubReferenceSegments(text, {
+      projectRepositories: task.project?.githubRepos,
+      taskRepository,
+    })) {
+      if (segment.kind !== "link") continue;
+      const key = segment.url.toLowerCase();
+      if (seen.has(key)) continue;
+      if (links.length === MAX_RELATED_GITHUB_LINKS) {
+        truncated = true;
+        break sourceLoop;
+      }
+      seen.add(key);
+      links.push(segment);
+    }
+  }
+  const repositories = new Set(links.map(({ owner, repository }) => `${owner}/${repository}`));
+  const repositoryNames = new Map();
+  for (const link of links) {
+    const owners = repositoryNames.get(link.repository) ?? new Set();
+    owners.add(link.owner);
+    repositoryNames.set(link.repository, owners);
+  }
+  const includeRepository = repositories.size > 1;
+  return {
+    relatedGitHubLinks: links.map((link) => ({
+      label: relatedLinkLabel(link, includeRepository, repositoryNames.get(link.repository).size > 1),
+      number: link.number,
+      owner: link.owner,
+      repository: link.repository,
+      type: link.type,
+      url: link.url,
+    })),
+    relatedGitHubLinksTruncated: truncated,
+    relatedGitHubRepository: taskRepository,
+  };
+}

package/src/dashboard/index.html

@@ -114,6 +114,7 @@
         </button>
         <button id="copy-thread-id" class="secondary-button" type="button">Copy thread ID</button>
       </div>
+      <nav id="dialog-related-links" class="github-links" aria-label="Related GitHub links" hidden></nav>
       <section>
         <h3>Activity timeline</h3>
         <div id="dialog-results" class="result-history"></div>

package/src/dashboard/styles.css

@@ -97,6 +97,15 @@ select { min-width: 180px; min-height: 36px; padding: 7px 32px 7px 10px; border:
 .task-title, .task-summary { overflow-wrap: anywhere; }
 .task-summary { display: grid; max-width: 82ch; margin-bottom: 12px; gap: 2px; font-size: 0.9rem; line-height: 1.45; }
 .task-summary strong { margin-top: 4px; color: var(--muted); font-size: 0.68rem; letter-spacing: 0.04em; text-transform: uppercase; }
+.github-links { display: flex; flex-wrap: wrap; gap: 7px; margin: 0 0 18px; }
+.github-links[hidden] { display: none; }
+.github-links-compact { margin: -2px 0 12px; gap: 5px; }
+.github-link { color: var(--accent); font-weight: 700; text-decoration-thickness: 1px; text-underline-offset: 3px; overflow-wrap: anywhere; }
+.github-link-compact { padding: 2px 7px; border: 1px solid var(--border); border-radius: 999px; background: var(--surface-muted); font-size: 0.72rem; line-height: 1.35; text-decoration: none; }
+.github-link:hover { text-decoration-thickness: 2px; }
+.github-link-compact:hover { border-color: var(--accent); background: var(--accent-soft); }
+.github-links-more { align-self: center; color: var(--muted); font-size: 0.75rem; font-weight: 700; }
+.github-reference-ambiguous { border-bottom: 2px dotted var(--warning); background: color-mix(in srgb, var(--warning) 12%, transparent); cursor: help; }
 time, .timestamp-missing { font-size: 0.75rem; }
 .timestamp-toggle { padding: 2px 0; border: 0; background: none; cursor: pointer; text-align: left; }
 .timestamp-toggle:hover time { color: var(--text); text-decoration: underline; text-underline-offset: 3px; }
@@ -136,7 +145,7 @@ time, .timestamp-missing { font-size: 0.75rem; }
 
 dialog { width: min(760px, calc(100vw - 32px)); max-height: min(82vh, 900px); padding: 28px; border: 1px solid var(--border); border-radius: 12px; background: var(--surface); color: var(--text); box-shadow: var(--shadow); }
 dialog::backdrop { background: rgb(18 23 21 / 50%); backdrop-filter: blur(2px); }
-.dialog-header { display: flex; justify-content: space-between; gap: 20px; }
+.dialog-header { display: flex; align-items: flex-start; justify-content: space-between; gap: 20px; }
 .dialog-header h2 { margin-bottom: 12px; font-size: 1.6rem; }
 .dialog-actions { display: flex; gap: 8px; margin-bottom: 26px; }
 .primary-button, .secondary-button { padding: 8px 12px; border-radius: 7px; font-weight: 700; cursor: pointer; }
@@ -173,6 +182,8 @@ pre { max-height: 280px; margin: 0; padding: 14px; overflow: auto; border-radius
   .task-heading { align-items: flex-start; }
   .task-title, .timestamp-toggle { display: flex; align-items: center; min-height: 36px; }
   .task-footer { align-items: flex-start; flex-direction: column; }
+  .github-links { max-width: 100%; }
+  .github-link-compact { padding-block: 5px; }
   .task-open { align-self: flex-start; }
   select { min-height: 40px; }
   .status-filter-option span { min-height: 38px; }

package/src/dashboard.js

@@ -17,6 +17,7 @@ import {
   readConfig,
 } from "./workspace.js";
 import { DASHBOARD_SERVER_VERSION, TASKCHEF_VERSION } from "./version.js";
+import { taskGitHubProjection } from "./dashboard/github-links.js";
 
 const TASKS_FILE_NAME = "tasks.jsonl";
 const STATIC_ROOT = fileURLToPath(new URL("./dashboard/", import.meta.url));
@@ -43,6 +44,7 @@ const STATIC_FILES = new Map([
   ["/", [path.join(STATIC_ROOT, "index.html"), "text/html; charset=utf-8"]],
   ["/actions.js", [path.join(STATIC_ROOT, "actions.js"), "text/javascript; charset=utf-8"]],
   ["/app.js", [path.join(STATIC_ROOT, "app.js"), "text/javascript; charset=utf-8"]],
+  ["/github-links.js", [path.join(STATIC_ROOT, "github-links.js"), "text/javascript; charset=utf-8"]],
   ["/time.js", [path.join(STATIC_ROOT, "time.js"), "text/javascript; charset=utf-8"]],
   ["/state.js", [path.join(STATIC_ROOT, "state.js"), "text/javascript; charset=utf-8"]],
   ["/styles.css", [path.join(STATIC_ROOT, "styles.css"), "text/css; charset=utf-8"]],
@@ -171,10 +173,17 @@ function assertDashboardTaskBounds(tasks, maximumTasks) {
 }
 
 function taskListProjection(task) {
-  const { turns: _turns, results: _results, ...projection } = task;
+  const { turns: _turns, results: _results, ...projection } = {
+    ...task,
+    ...taskGitHubProjection(task),
+  };
   return projection;
 }
 
+function taskDetailProjection(task) {
+  return { ...task, ...taskGitHubProjection(task) };
+}
+
 export class DashboardMonitor extends EventEmitter {
   constructor(workspace, {
     debounceMs = 75,
@@ -548,7 +557,7 @@ export async function createDashboardServer({
         response.writeHead(200, securityHeaders("application/json; charset=utf-8"));
         response.end();
       } else {
-        sendJson(response, 200, { schemaVersion: 1, task });
+        sendJson(response, 200, { schemaVersion: 1, task: taskDetailProjection(task) });
       }
       return;
     }

package/src/mcp.js

@@ -225,7 +225,7 @@ export function createTaskChefMcpServer({
     {
       title: "Report TaskChef state",
       description:
-        "Report this self-linked executor turn's lifecycle state. Use working before substantive work in a newly linked or follow-up turn, with summary omitted or null and a concise requestSummary. Before ending the same turn, report needs_input, completed, or failed with a concise semantic summary and requestSummary omitted. Exact retries are idempotent; stale or mismatched turns are rejected.",
+        "Report this self-linked executor turn's lifecycle state. Use working before substantive work in a newly linked or follow-up turn, with summary omitted or null and a concise requestSummary. Preserve known repository context and delivered issues or pull requests as canonical GitHub URLs, including both child-repository and workspace pull requests when applicable. Before ending the same turn, report needs_input, completed, or failed with a concise semantic summary and requestSummary omitted. Exact retries are idempotent; stale or mismatched turns are rejected.",
       inputSchema: {
         taskId: z.string().min(1),
         threadId: z.string().min(1).nullable(),