Sync GitHub b8539eb

Add paper-style publication metadata rows, source provenance, responsive Resource Atlas rendering, and CI validation.

.github/workflows/quality.yml

@@ -51,6 +51,9 @@ jobs:
       - name: Check resource dataset export
         run: python scripts/export_resource_dataset.py --check
 
+      - name: Check publication metadata
+        run: python scripts/check_publication_metadata.py
+
       - name: Check loop contract examples
         run: |
           python scripts/check_loop_contract_examples.py

README.md

@@ -1107,3 +1107,82 @@ If this repository is useful in your work, please cite it with:
 **Reusable blurb** (for blog posts, talks, internal docs, or community posts):
 
 > Loop Engineering is the practice of designing recurring AI-agent and coding-agent systems that discover work, delegate to agents, verify results, persist state, and retry or escalate on a cadence or until a goal is reached. *Awesome Loop Engineering* is a curated, implementation-focused resource collection for this practice: [github.com/ChaoYue0307/awesome-loop-engineering](https://github.com/ChaoYue0307/awesome-loop-engineering)
+
+---
+
+## Dataset Structure
+
+Each row in `data/resources.jsonl` (and the equivalent `data/resources.csv`) is one curated resource, exported from the English `README.md`.
+
+| Field | Description |
+| --- | --- |
+| `row_id` | Positional identifier (`ale-NNNN`); not stable across README reorders. |
+| `section` | The `##` section the entry lives under. |
+| `section_slug` | Anchor-style slug of the section. |
+| `resource_type` | Paper, Blog, Docs, Tool, Benchmark, Pattern, Template, List, or Critique. |
+| `marker` | Emoji shown before the entry in the README. |
+| `title` | Linked entry title. |
+| `url` | Resource URL. |
+| `url_kind` | `external` or `local_path` (a file inside the repository). |
+| `domain` | Host of an external URL (empty for local paths). |
+| `annotation` | The one-line description as written in the README. |
+| `description` | Copy of the annotation for tooling that expects a `description` field. |
+| `key_contribution` | Short statement of what the resource adds. |
+| `novelty` | Why the entry is distinct within its section. |
+| `impact` | Who benefits and how. |
+| `signal` | Why the entry is trustworthy (adoption, venue, authorship). |
+| `signal_strength` | Calibrated confidence label (`high`, `medium`, `contextual`, or `unverified`). |
+| `source_readme` | README file the row came from. |
+| `source_line` | 1-based line number in that README. |
+| `source_url` | Permalink to the source line on GitHub. |
+| `date_added` | First-seen date when tracked; blank for resources added before tracking began. |
+| `collection` | Task-oriented atlas group: Learn, Design, Build, Persist, Verify, Govern, or Apply. |
+| `collection_slug` | Stable lowercase slug for the task-oriented collection. |
+| `user_goal` | Reader outcome served by the collection. |
+| `lifecycle_stages` | Semicolon-delimited Loop Contract stages addressed by the resource. |
+| `audience` | Semicolon-delimited intended audiences, such as newcomer, builder, operator, evaluator, or security. |
+| `evidence_class` | Source-provenance category, independent of popularity or editorial judgment. |
+| `source_status` | Latest audit result: `ok`, `restricted`, `local_ok`, or an explicit failure state. |
+| `canonical_url` | Redirect-resolved or repository-canonical URL used for source verification. |
+| `source_title` | Title metadata retrieved during the latest source audit. |
+| `source_description` | Description or abstract metadata retrieved from the primary source. |
+| `authors` | Semicolon-delimited authors from primary bibliographic metadata when available. |
+| `publication_date` | Primary-source publication or repository creation date in ISO format when available. |
+| `publication_year` | Four-digit year derived from the verified publication date or identifier. |
+| `publication_venue` | Journal, conference, repository, or named venue reported by the source. |
+| `publisher` | Publishing organization or source platform; falls back to the canonical domain. |
+| `doi` | Normalized DOI without a URL prefix when available. |
+| `publication_note` | Primary-source journal reference, acceptance note, or publication comment when available. |
+| `primary_category` | Primary arXiv category when applicable. |
+| `metadata_source` | Provenance for bibliographic fields, such as `arxiv-api`, `github-api`, `html-meta`, or `domain-fallback`. |
+| `github_repo` | Normalized GitHub `owner/repository` identifier where applicable. |
+| `github_stars` | GitHub star count captured at audit time; context, not a reliability score. |
+| `github_forks` | GitHub fork count captured at audit time. |
+| `github_license` | Repository license identifier reported by GitHub where available. |
+| `github_created_at` | Repository creation timestamp reported by GitHub. |
+| `github_updated_at` | Latest repository update timestamp reported by GitHub. |
+| `arxiv_id` | arXiv identifier extracted from a primary paper URL where applicable. |
+| `audited_at` | UTC timestamp for the source metadata and availability snapshot. |
+
+## Considerations and Limitations
+
+- Annotations are written and curated by a single maintainer; they summarize each resource and are not the authors' own abstracts.
+- URLs are third-party and can rot; `data/resource_source_audit.csv` carries a retrieval-time reachability snapshot, but it is a point-in-time check, not a live guarantee.
+- `row_id` and `source_line` are positional and change when the README is reordered; join on `url` for anything durable.
+- `signal_strength` is calibrated as `high`, `medium`, `contextual`, or `unverified`; GitHub stars and forks are reported only as adoption context.
+- Coverage skews toward English-language, publicly available resources.
+
+## Changelog
+
+Versioned changes are published as [GitHub Releases](https://github.com/ChaoYue0307/awesome-loop-engineering/releases).
+
+## Citation
+
+```bibtex
+@misc{chaoyue2026awesome_loop_engineering,
+  author       = {He, Chaoyue},
+  title        = {Awesome Loop Engineering},
+  year         = {2026},
+  howpublished = {\url{https://github.com/ChaoYue0307/awesome-loop-engineering}}
+}
+```

data/README.md

@@ -8,10 +8,11 @@ This directory contains generated tabular exports of the canonical English `READ
 - `first_seen.json` - Forward-only sidecar mapping resource URL to the date it was first added; the export left-joins it into the `date_added` column. Empty `date_added` means the entry predates per-entry tracking (started 2026-07-15).
 - `resource_source_audit.csv` - Retrieval-time audit of every row, including URL status, source title metadata, arXiv IDs, and GitHub repository stats where available.
 
-The main exports preserve the original section and annotation while adding two complementary discovery layers:
+The main exports preserve the original section and annotation while adding three complementary discovery layers:
 
 - **Task facets**: `collection`, `user_goal`, `lifecycle_stages`, and `audience` answer why a reader needs the source and where it fits in the Loop Contract.
 - **Evidence facets**: `evidence_class`, `signal_strength`, `source_status`, canonical URL, source metadata, GitHub statistics, arXiv ID, and audit timestamp separate source provenance from popularity or editorial judgment.
+- **Publication facets**: `authors`, `publication_date`, `publication_year`, `publication_venue`, `publisher`, `doi`, `publication_note`, `primary_category`, and `metadata_source` provide a paper-like bibliographic row without inventing missing facts.
 
 `key_contribution`, `novelty`, and `impact` are resource-specific. `signal` states the evidence basis and its limits; GitHub stars and forks are reported as current context, never as proof of reliability. Signal strength is calibrated as `high` for primary official documentation and benchmarks, `medium` for inspectable implementations, papers, patterns, and repository-native artifacts, `contextual` for practitioner analysis and curated lists, and `unverified` only when the latest source audit cannot validate availability.
 
@@ -29,4 +30,4 @@ Run a network-backed source audit when refreshing the Hugging Face dataset:
 python3 scripts/audit_resource_sources.py --timeout 20 --workers 16 --attempts 2 --github-cli
 ```
 
-The audit file is a snapshot. HTTP status, redirects, page titles, and GitHub stars/forks can change over time. Rows marked `restricted` returned an access-control or rate-limit status during retrieval; they are tracked separately from broken or unreachable links.
+The audit file is a snapshot. HTTP status, redirects, page titles, publication metadata, and GitHub statistics can change over time. arXiv bibliographic fields come from the primary arXiv API; GitHub dates come from the repository API; other web metadata comes from citation or Open Graph tags when available. A blank publication date means the primary source did not expose one. Rows marked `restricted` returned an access-control or rate-limit status during retrieval; they are tracked separately from broken or unreachable links.

docs/index.html

@@ -435,23 +435,50 @@
       .resource-count { margin: 0; color: var(--muted); font-size: 0.86rem; }
       .resource-sort { width: auto; min-width: 176px; }
       .resource-list { min-height: 180px; }
+      .resource-row-head {
+        display: grid;
+        grid-template-columns: minmax(0, 1.5fr) 72px minmax(170px, 0.55fr) minmax(130px, 0.4fr);
+        gap: 22px;
+        padding: 11px 0;
+        border-bottom: 1px solid var(--line-strong);
+        color: var(--quiet);
+        font-family: "IBM Plex Mono", ui-monospace, monospace;
+        font-size: 0.66rem;
+        font-weight: 650;
+        text-transform: uppercase;
+      }
       .resource-item {
         display: grid;
-        grid-template-columns: minmax(0, 1fr) 180px;
-        gap: 28px;
-        padding: 17px 0;
+        grid-template-columns: minmax(0, 1.5fr) 72px minmax(170px, 0.55fr) minmax(130px, 0.4fr);
+        gap: 12px 22px;
+        align-items: start;
+        padding: 18px 0 16px;
         border-bottom: 1px solid var(--line);
       }
-      .resource-item a { color: var(--ink); font-weight: 750; text-decoration: none; }
-      .resource-item a:hover { color: var(--blue); }
-      .resource-item p { max-width: 850px; margin: 6px 0 0; color: var(--muted); font-size: 0.88rem; }
-      .resource-meta { margin-top: 7px; color: var(--quiet); font-family: "IBM Plex Mono", ui-monospace, monospace; font-size: 0.7rem; overflow-wrap: anywhere; }
-      .resource-side { color: var(--quiet); font-size: 0.74rem; text-align: right; }
-      .resource-signal { display: block; color: var(--green); font-weight: 700; text-transform: uppercase; }
+      .resource-work, .resource-publication, .resource-evidence { min-width: 0; }
+      .resource-title { color: var(--ink); font-weight: 760; line-height: 1.35; text-decoration: none; }
+      .resource-title:hover { color: var(--blue); }
+      .resource-item p { margin: 0; }
+      .resource-contribution { margin-top: 6px !important; color: var(--muted); font-size: 0.86rem; line-height: 1.5; }
+      .resource-authors { margin-top: 7px !important; color: var(--quiet); font-size: 0.76rem; line-height: 1.45; }
+      .resource-meta { margin-top: 7px; color: var(--quiet); font-family: "IBM Plex Mono", ui-monospace, monospace; font-size: 0.68rem; overflow-wrap: anywhere; }
+      .resource-cell-label { display: none; margin-bottom: 5px; color: var(--quiet); font-family: "IBM Plex Mono", ui-monospace, monospace; font-size: 0.62rem; font-weight: 650; text-transform: uppercase; }
+      .resource-year-value { color: var(--ink); font-family: "IBM Plex Mono", ui-monospace, monospace; font-size: 0.9rem; font-weight: 700; }
+      .resource-year-value.undated { color: var(--quiet); font-weight: 500; }
+      .resource-venue { display: block; color: var(--ink); font-size: 0.82rem; font-weight: 700; line-height: 1.4; overflow-wrap: anywhere; }
+      .resource-publisher, .resource-date, .resource-identifier { display: block; margin-top: 4px; color: var(--quiet); font-size: 0.72rem; line-height: 1.4; overflow-wrap: anywhere; }
+      .resource-type-label { display: block; color: var(--ink); font-size: 0.78rem; font-weight: 700; }
+      .resource-signal { display: block; margin-top: 5px; color: var(--green); font-size: 0.68rem; font-weight: 700; text-transform: uppercase; }
       .resource-signal.contextual { color: var(--violet); }
       .resource-signal.medium { color: var(--blue); }
       .resource-signal.unverified { color: var(--quiet); }
-      .resource-source-status { display: block; margin-top: 4px; }
+      .resource-source-status { display: block; margin-top: 4px; color: var(--quiet); font-size: 0.7rem; line-height: 1.4; }
+      .resource-details, .resource-details:last-child { grid-column: 1 / -1; margin-top: 2px; border: 0; border-top: 1px dashed var(--line); border-bottom: 0; padding: 9px 0 0; }
+      .resource-details summary { width: fit-content; color: var(--blue); font-size: 0.72rem; font-weight: 700; }
+      .resource-detail-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 16px 28px; padding: 14px 0 4px; }
+      .resource-detail h4 { margin: 0 0 5px; color: var(--quiet); font-family: "IBM Plex Mono", ui-monospace, monospace; font-size: 0.64rem; text-transform: uppercase; }
+      .resource-detail p { color: var(--muted); font-size: 0.78rem; line-height: 1.5; }
+      .resource-bibliography + .resource-bibliography { margin-top: 5px; }
       .resource-actions { display: flex; justify-content: center; padding-top: 18px; }
       .resource-empty, .resource-loading { margin: 0; padding: 28px 0; color: var(--muted); }
       details { border-top: 1px solid var(--line-strong); padding: 18px 0; }
@@ -539,6 +566,11 @@
         .resource-toolbar { grid-template-columns: repeat(2, minmax(0, 1fr)); }
         .resource-toolbar label:first-child { grid-column: 1 / -1; }
         .resource-reset { width: 100%; }
+        .resource-row-head { display: none; }
+        .resource-item { grid-template-columns: 72px minmax(0, 1fr) minmax(120px, 0.72fr); gap: 14px 18px; }
+        .resource-work, .resource-details { grid-column: 1 / -1; }
+        .resource-cell-label { display: block; }
+        .resource-detail-grid { gap: 14px 22px; }
         .footer-grid { grid-template-columns: 1fr 1fr; }
         .loop-stage-rail { grid-template-columns: repeat(3, minmax(0, 1fr)); }
         .loop-stage:nth-child(4) { border-left: 0; }
@@ -598,8 +630,11 @@
         .resource-collection { min-width: 0; min-height: 40px; padding-inline: 4px; font-size: 0.75rem; }
         .resource-summary { align-items: stretch; flex-direction: column; gap: 10px; padding: 14px 0; }
         .resource-sort { width: 100%; }
-        .resource-item { grid-template-columns: 1fr; gap: 8px; padding: 15px 0; }
-        .resource-side { text-align: left; }
+        .resource-item { grid-template-columns: 1fr; gap: 12px; padding: 17px 0; }
+        .resource-work, .resource-details { grid-column: auto; }
+        .resource-year, .resource-publication, .resource-evidence { padding-top: 10px; border-top: 1px solid var(--line); }
+        .resource-detail-grid { grid-template-columns: 1fr; gap: 14px; }
+        .resource-details summary { min-height: 34px; padding-top: 5px; }
         .caption { text-align: left; }
         .level { grid-template-columns: 46px 1fr; }
         .level { gap: 12px; padding: 14px 0; }
@@ -976,7 +1011,7 @@
               <p class="section-label">06 / Curated resources</p>
               <h2>Find the evidence for your next decision.</h2>
             </div>
-            <p class="section-intro">Search 509 audited sources by goal, lifecycle stage, artifact type, and evidence class. Every result preserves its curated annotation and links directly to the canonical source.</p>
+            <p class="section-intro">Search 509 audited works by goal, lifecycle stage, artifact type, and evidence class. Each row combines the curated assessment with verified authorship, year, venue or source platform, and identifiers when the primary source exposes them.</p>
           </div>
           <div class="resource-explorer" id="resource-explorer">
             <div class="resource-toolbar" role="search" aria-label="Search curated resources">
@@ -1047,11 +1082,18 @@
                 <span class="sr-only">Sort resources</span>
                 <select class="resource-select resource-sort" id="resource-sort">
                   <option value="curated">Curated order</option>
+                  <option value="publication">Publication year</option>
                   <option value="stars">GitHub stars</option>
                   <option value="recent">Recently added</option>
                 </select>
               </label>
             </div>
+            <div class="resource-row-head" aria-hidden="true">
+              <span>Work and key contribution</span>
+              <span>Year</span>
+              <span>Published at</span>
+              <span>Evidence</span>
+            </div>
             <div class="resource-list" id="resource-list" aria-busy="true">
               <p class="resource-loading">Loading audited resources...</p>
             </div>
@@ -1292,6 +1334,44 @@
           return element;
         }
 
+        function appendCellLabel(element, value) {
+          element.appendChild(createText('span', 'resource-cell-label', value));
+        }
+
+        function authorNames(value) {
+          return String(value || '').split(';').map(function (name) { return name.trim(); }).filter(Boolean);
+        }
+
+        function formattedAuthors(value) {
+          var names = authorNames(value);
+          if (names.length <= 4) return names.join(', ');
+          return names.slice(0, 4).join(', ') + ' +' + (names.length - 4) + ' more';
+        }
+
+        function identifier(resource) {
+          if (resource.doi) return 'DOI ' + resource.doi;
+          if (resource.arxiv_id) return 'arXiv ' + resource.arxiv_id;
+          if (resource.github_repo) return resource.github_repo;
+          return '';
+        }
+
+        function sourceStatus(resource) {
+          if (resource.source_status === 'restricted') return 'Access restricted';
+          if (['broken', 'unreachable', 'local_missing'].indexOf(resource.source_status) !== -1) return 'Audit issue';
+          if (String(resource.source_status || '').indexOf('local') === 0) return 'Repository source';
+          return 'Source checked';
+        }
+
+        function detailSection(title, values) {
+          var section = document.createElement('div');
+          section.className = 'resource-detail';
+          section.appendChild(createText('h4', '', title));
+          values.filter(Boolean).forEach(function (value) {
+            section.appendChild(createText('p', 'resource-bibliography', value));
+          });
+          return section;
+        }
+
         function resourceMatches(resource) {
           var query = search.value.trim().toLowerCase();
           var haystack = [
@@ -1302,7 +1382,16 @@
             resource.user_goal,
             resource.lifecycle_stages,
             resource.audience,
-            resource.evidence_class
+            resource.evidence_class,
+            resource.authors,
+            resource.publication_year,
+            resource.publication_venue,
+            resource.publisher,
+            resource.doi,
+            resource.arxiv_id,
+            resource.key_contribution,
+            resource.novelty,
+            resource.impact
           ].join(' ').toLowerCase();
           var evidenceSet = evidenceGroups[evidence.value] || [];
 
@@ -1315,6 +1404,11 @@
 
         function sortedResources(filtered) {
           return filtered.slice().sort(function (a, b) {
+            if (sort.value === 'publication') {
+              return Number(b.publication_year || 0) - Number(a.publication_year || 0) ||
+                (Date.parse(b.publication_date || '') || 0) - (Date.parse(a.publication_date || '') || 0) ||
+                a._index - b._index;
+            }
             if (sort.value === 'stars') {
               return Number(b.github_stars || 0) - Number(a.github_stars || 0) || a._index - b._index;
             }
@@ -1327,31 +1421,80 @@
 
         function renderItem(resource) {
           var item = document.createElement('article');
-          var main = document.createElement('div');
-          var link = createText('a', '', resource.title);
+          var work = document.createElement('div');
+          var year = document.createElement('div');
+          var publication = document.createElement('div');
+          var evidenceCell = document.createElement('div');
+          var details = document.createElement('details');
+          var detailGrid = document.createElement('div');
+          var link = createText('a', 'resource-title', resource.title);
+          var authors = formattedAuthors(resource.authors);
+          var fullAuthors = authorNames(resource.authors).join(', ');
           var meta = [
-            resource.resource_type,
             resource.collection,
+            resource.section,
             stages(resource.lifecycle_stages).map(words).join(' / '),
             words(resource.evidence_class)
           ].filter(Boolean).join(' | ');
-          var side = document.createElement('div');
           var signalClass = 'resource-signal ' + String(resource.signal_strength || 'unverified').toLowerCase();
           var signal = createText('span', signalClass, words(resource.signal_strength || 'unverified') + ' signal');
-          var sourceStatus = resource.source_status === 'restricted' ? 'Access restricted' : 'Source checked';
           var starCount = formatNumber(resource.github_stars);
+          var venue = resource.publication_venue || resource.publisher || 'Source not stated';
+          var publicationId = identifier(resource);
+          var sourceRecord = [
+            fullAuthors ? 'Authors: ' + fullAuthors : '',
+            resource.publication_date ? 'Published: ' + resource.publication_date : 'Publication date: not stated by the source',
+            'Source: ' + venue + (resource.publisher && resource.publisher !== venue ? ' | ' + resource.publisher : ''),
+            publicationId ? 'Identifier: ' + publicationId : '',
+            resource.primary_category ? 'Primary category: ' + resource.primary_category : '',
+            resource.publication_note ? 'Source note: ' + resource.publication_note : '',
+            resource.metadata_source ? 'Metadata provenance: ' + words(resource.metadata_source) : ''
+          ];
 
           item.className = 'resource-item';
           link.href = resource.canonical_url || resource.url;
-          main.appendChild(link);
-          main.appendChild(createText('p', '', resource.annotation));
-          main.appendChild(createText('div', 'resource-meta', meta));
-          side.className = 'resource-side';
-          side.appendChild(signal);
-          if (starCount) side.appendChild(createText('span', 'resource-source-status', starCount + ' GitHub stars'));
-          side.appendChild(createText('span', 'resource-source-status', sourceStatus));
-          item.appendChild(main);
-          item.appendChild(side);
+          work.className = 'resource-work';
+          work.appendChild(link);
+          work.appendChild(createText('p', 'resource-contribution', resource.key_contribution || resource.annotation));
+          if (authors) {
+            var authorLine = createText('p', 'resource-authors', authors);
+            authorLine.title = fullAuthors;
+            work.appendChild(authorLine);
+          }
+          work.appendChild(createText('div', 'resource-meta', meta));
+
+          year.className = 'resource-year';
+          appendCellLabel(year, 'Year');
+          year.appendChild(createText('span', 'resource-year-value' + (resource.publication_year ? '' : ' undated'), resource.publication_year || 'n.d.'));
+
+          publication.className = 'resource-publication';
+          appendCellLabel(publication, 'Published at');
+          publication.appendChild(createText('span', 'resource-venue', venue));
+          if (resource.publisher && resource.publisher !== venue) publication.appendChild(createText('span', 'resource-publisher', resource.publisher));
+          if (resource.publication_date && resource.publication_date !== resource.publication_year) publication.appendChild(createText('span', 'resource-date', resource.publication_date));
+          if (publicationId) publication.appendChild(createText('span', 'resource-identifier', publicationId));
+
+          evidenceCell.className = 'resource-evidence';
+          appendCellLabel(evidenceCell, 'Evidence');
+          evidenceCell.appendChild(createText('span', 'resource-type-label', resource.resource_type));
+          evidenceCell.appendChild(signal);
+          if (starCount) evidenceCell.appendChild(createText('span', 'resource-source-status', starCount + ' GitHub stars'));
+          evidenceCell.appendChild(createText('span', 'resource-source-status', sourceStatus(resource)));
+
+          details.className = 'resource-details';
+          details.appendChild(createText('summary', '', 'Contribution, novelty, impact, and source record'));
+          detailGrid.className = 'resource-detail-grid';
+          detailGrid.appendChild(detailSection('Contribution', [resource.key_contribution || resource.annotation]));
+          detailGrid.appendChild(detailSection('Novelty', [resource.novelty]));
+          detailGrid.appendChild(detailSection('Impact', [resource.impact]));
+          detailGrid.appendChild(detailSection('Source record', sourceRecord.concat(resource.signal ? ['Evidence: ' + resource.signal] : [])));
+          details.appendChild(detailGrid);
+
+          item.appendChild(work);
+          item.appendChild(year);
+          item.appendChild(publication);
+          item.appendChild(evidenceCell);
+          item.appendChild(details);
           return item;
         }
 

meta/hf_card_body.md

@@ -35,10 +35,20 @@ Each row in `data/resources.jsonl` (and the equivalent `data/resources.csv`) is
 | `canonical_url` | Redirect-resolved or repository-canonical URL used for source verification. |
 | `source_title` | Title metadata retrieved during the latest source audit. |
 | `source_description` | Description or abstract metadata retrieved from the primary source. |
+| `authors` | Semicolon-delimited authors from primary bibliographic metadata when available. |
+| `publication_date` | Primary-source publication or repository creation date in ISO format when available. |
+| `publication_year` | Four-digit year derived from the verified publication date or identifier. |
+| `publication_venue` | Journal, conference, repository, or named venue reported by the source. |
+| `publisher` | Publishing organization or source platform; falls back to the canonical domain. |
+| `doi` | Normalized DOI without a URL prefix when available. |
+| `publication_note` | Primary-source journal reference, acceptance note, or publication comment when available. |
+| `primary_category` | Primary arXiv category when applicable. |
+| `metadata_source` | Provenance for bibliographic fields, such as `arxiv-api`, `github-api`, `html-meta`, or `domain-fallback`. |
 | `github_repo` | Normalized GitHub `owner/repository` identifier where applicable. |
 | `github_stars` | GitHub star count captured at audit time; context, not a reliability score. |
 | `github_forks` | GitHub fork count captured at audit time. |
 | `github_license` | Repository license identifier reported by GitHub where available. |
+| `github_created_at` | Repository creation timestamp reported by GitHub. |
 | `github_updated_at` | Latest repository update timestamp reported by GitHub. |
 | `arxiv_id` | arXiv identifier extracted from a primary paper URL where applicable. |
 | `audited_at` | UTC timestamp for the source metadata and availability snapshot. |

scripts/audit_resource_sources.py

@@ -15,10 +15,11 @@ import sys
 import time
 import urllib.error
 import urllib.request
+import xml.etree.ElementTree as ET
 from datetime import datetime, timezone
 from html.parser import HTMLParser
 from pathlib import Path
-from urllib.parse import urldefrag, urlparse
+from urllib.parse import urldefrag, urlencode, urlparse
 
 
 ROOT = Path(__file__).resolve().parents[1]
@@ -27,6 +28,53 @@ AUDIT_CSV = ROOT / "data" / "resource_source_audit.csv"
 REPO_BLOB_URL = "https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main"
 
 ARXIV_RE = re.compile(r"arxiv\.org/(?:abs|pdf)/(?P<id>\d{4}\.\d{4,5})(?:v\d+)?")
+YEAR_RE = re.compile(r"(?<!\d)(?P<year>19\d{2}|20\d{2})(?!\d)")
+ISO_DATE_RE = re.compile(r"(?P<year>19\d{2}|20\d{2})[-/](?P<month>\d{1,2})[-/](?P<day>\d{1,2})")
+
+ATOM_NS = "{http://www.w3.org/2005/Atom}"
+ARXIV_NS = "{http://arxiv.org/schemas/atom}"
+
+PUBLISHER_BY_DOMAIN = {
+    "arxiv.org": "arXiv",
+    "github.com": "GitHub",
+    "anthropic.com": "Anthropic",
+    "claude.com": "Anthropic",
+    "openai.com": "OpenAI",
+    "huggingface.co": "Hugging Face",
+    "microsoft.com": "Microsoft",
+    "google.com": "Google",
+    "googleblog.com": "Google",
+    "aws.amazon.com": "Amazon Web Services",
+    "amazon.com": "Amazon",
+    "preprints.org": "Preprints.org",
+    "ainowinstitute.org": "AI Now Institute",
+    "medium.com": "Medium",
+    "substack.com": "Substack",
+    "x.com": "X",
+    "youtube.com": "YouTube",
+}
+
+PUBLICATION_OVERRIDES = {
+    "https://www.preprints.org/manuscript/202603.1756": {
+        "authors": "Chaoyue He; Xin Zhou; Di Wang; Hong Xu; Wei Liu; Chunyan Miao",
+        "publication_date": "2026-04-23",
+        "publication_year": "2026",
+        "publication_venue": "Preprints.org",
+        "publisher": "Preprints.org",
+        "doi": "10.20944/preprints202603.1756.v2",
+        "publication_note": "Version 2; the primary source states that this preprint is not peer-reviewed.",
+        "metadata_source": "primary-page",
+    },
+    "https://resources.anthropic.com/hubfs/Building%20Effective%20AI%20Agents-%20Architecture%20Patterns%20and%20Implementation%20Frameworks.pdf": {
+        "authors": "Anthropic",
+        "publication_date": "2025-12-03",
+        "publication_year": "2025",
+        "publication_venue": "Anthropic eBook",
+        "publisher": "Anthropic",
+        "publication_note": "Date verified from the primary PDF creation metadata.",
+        "metadata_source": "pdf-metadata",
+    },
+}
 
 FIELDS = [
     "row_id",
@@ -40,12 +88,22 @@ FIELDS = [
     "content_type",
     "source_title",
     "source_description",
+    "authors",
+    "publication_date",
+    "publication_year",
+    "publication_venue",
+    "publisher",
+    "doi",
+    "publication_note",
+    "primary_category",
+    "metadata_source",
     "github_repo",
     "github_stars",
     "github_forks",
     "github_open_issues",
     "github_description",
     "github_license",
+    "github_created_at",
     "github_updated_at",
     "arxiv_id",
     "error",
@@ -68,6 +126,7 @@ class MetadataParser(HTMLParser):
         self.title_parts: list[str] = []
         self.description = ""
         self.description_priority = 0
+        self.meta_values: dict[str, list[str]] = {}
 
     @property
     def title(self) -> str:
@@ -81,7 +140,10 @@ class MetadataParser(HTMLParser):
             return
 
         attr_map = {key.lower(): value or "" for key, value in attrs}
-        name = (attr_map.get("name") or attr_map.get("property") or "").lower()
+        name = (attr_map.get("name") or attr_map.get("property") or attr_map.get("itemprop") or "").lower()
+        candidate = clean(attr_map.get("content"))
+        if name and candidate:
+            self.meta_values.setdefault(name, []).append(candidate)
         priority = {
             "description": 1,
             "og:description": 1,
@@ -89,7 +151,6 @@ class MetadataParser(HTMLParser):
             "dc.description": 2,
             "citation_abstract": 3,
         }.get(name, 0)
-        candidate = clean(attr_map.get("content"))
         if candidate and priority > self.description_priority:
             self.description = candidate
             self.description_priority = priority
@@ -102,6 +163,20 @@ class MetadataParser(HTMLParser):
         if self.in_title:
             self.title_parts.append(data)
 
+    def first(self, *names: str) -> str:
+        for name in names:
+            values = self.meta_values.get(name.lower(), [])
+            if values:
+                return values[0]
+        return ""
+
+    def all(self, *names: str) -> list[str]:
+        for name in names:
+            values = self.meta_values.get(name.lower(), [])
+            if values:
+                return list(dict.fromkeys(values))
+        return []
+
 
 class RedirectHandler(urllib.request.HTTPRedirectHandler):
     """Teach Python 3.9's urllib opener to follow permanent HTTP 308 moves."""
@@ -135,16 +210,80 @@ def arxiv_id_from_url(url: str) -> str:
     return match.group("id") if match else ""
 
 
-def html_metadata(body: bytes, content_type: str) -> tuple[str, str]:
+def normalize_date(value: str) -> str:
+    value = clean(value)
+    if not value:
+        return ""
+    match = ISO_DATE_RE.search(value)
+    if match:
+        return f"{match.group('year')}-{int(match.group('month')):02d}-{int(match.group('day')):02d}"
+    year = YEAR_RE.search(value)
+    return year.group("year") if year else ""
+
+
+def year_from_value(value: str) -> str:
+    match = YEAR_RE.search(value or "")
+    return match.group("year") if match else ""
+
+
+def normalize_doi(value: str) -> str:
+    value = clean(value)
+    for prefix in ("https://doi.org/", "http://doi.org/", "doi:"):
+        if value.lower().startswith(prefix):
+            value = value[len(prefix) :]
+            break
+    return value.strip()
+
+
+def publisher_for_domain(domain: str) -> str:
+    normalized = domain.lower().removeprefix("www.")
+    for suffix, publisher in PUBLISHER_BY_DOMAIN.items():
+        if normalized == suffix or normalized.endswith(f".{suffix}"):
+            return publisher
+    return normalized
+
+
+def html_metadata(body: bytes, content_type: str) -> dict[str, str]:
     if "html" not in content_type.lower():
-        return "", ""
+        return {}
     text = body[:750_000].decode("utf-8", errors="ignore")
     parser = MetadataParser()
     try:
         parser.feed(text)
     except Exception:  # noqa: BLE001 - source metadata should not fail the URL audit.
-        return "", ""
-    return parser.title, parser.description
+        return {}
+
+    authors = parser.all("citation_author", "dc.creator", "author")
+    publication_date = normalize_date(
+        parser.first(
+            "citation_publication_date",
+            "citation_date",
+            "article:published_time",
+            "datepublished",
+            "dc.date.issued",
+            "dc.date",
+            "date",
+        )
+    )
+    publication_venue = parser.first(
+        "citation_conference_title",
+        "citation_journal_title",
+        "citation_technical_report_institution",
+    )
+    publisher = parser.first("citation_publisher", "dc.publisher", "og:site_name", "application-name")
+    doi = normalize_doi(parser.first("citation_doi", "dc.identifier.doi", "doi"))
+    has_publication_metadata = any((authors, publication_date, publication_venue, publisher, doi))
+    return {
+        "source_title": parser.title,
+        "source_description": parser.description,
+        "authors": "; ".join(authors),
+        "publication_date": publication_date,
+        "publication_year": year_from_value(publication_date),
+        "publication_venue": publication_venue,
+        "publisher": publisher,
+        "doi": doi,
+        "metadata_source": "html-meta" if has_publication_metadata else "",
+    }
 
 
 def fetch_url(url: str, timeout: float, attempts: int) -> dict[str, str]:
@@ -154,36 +293,72 @@ def fetch_url(url: str, timeout: float, attempts: int) -> dict[str, str]:
         RedirectHandler(),
     )
     last_error = ""
+    parsed_url = urlparse(url)
+    request_url = url
 
     for attempt in range(1, attempts + 1):
         for method in ("GET", "HEAD"):
             request = urllib.request.Request(
-                url,
+                request_url,
                 method=method,
                 headers={"User-Agent": "awesome-loop-engineering-source-audit"},
             )
             try:
                 with opener.open(request, timeout=timeout) as response:
+                    final_url = response.geturl()
+                    final_host = urlparse(final_url).netloc.lower()
+                    if parsed_url.netloc.lower() == "code.claude.com" and final_host not in {
+                        "",
+                        "code.claude.com",
+                        "docs.anthropic.com",
+                    }:
+                        return {
+                            "audit_status": "restricted",
+                            "http_status": str(response.status),
+                            "final_url": request_url,
+                            "content_type": response.headers.get("content-type", ""),
+                            "source_title": "",
+                            "source_description": "",
+                            "error": f"redirected_to_unrelated_host:{final_host}",
+                        }
                     content_type = response.headers.get("content-type", "")
                     body = response.read(750_000) if method == "GET" else b""
-                    title, description = html_metadata(body, content_type)
-                    return {
+                    metadata = html_metadata(body, content_type)
+                    result = {
                         "audit_status": "ok",
                         "http_status": str(response.status),
-                        "final_url": response.geturl(),
+                        "final_url": final_url,
                         "content_type": content_type,
-                        "source_title": title,
-                        "source_description": description,
                         "error": "",
                     }
+                    result.update(metadata)
+                    return result
             except urllib.error.HTTPError as error:
                 if method == "HEAD":
                     continue
+                error_host = urlparse(error.geturl()).netloc.lower()
+                if parsed_url.netloc.lower() == "code.claude.com" and error_host not in {
+                    "",
+                    "code.claude.com",
+                    "docs.anthropic.com",
+                }:
+                    return {
+                        "audit_status": "restricted",
+                        "http_status": str(error.code),
+                        "final_url": request_url,
+                        "content_type": error.headers.get("content-type", "") if error.headers else "",
+                        "source_title": "",
+                        "source_description": "",
+                        "error": f"redirected_to_unrelated_host:{error_host}",
+                    }
+                if error.code == 404 and parsed_url.netloc.lower() == "code.claude.com" and attempt < attempts:
+                    last_error = "HTTPError:404"
+                    break
                 if error.code in RESTRICTED_HTTP:
                     return {
                         "audit_status": "restricted",
                         "http_status": str(error.code),
-                        "final_url": url,
+                        "final_url": request_url,
                         "content_type": error.headers.get("content-type", "") if error.headers else "",
                         "source_title": "",
                         "source_description": "",
@@ -192,7 +367,7 @@ def fetch_url(url: str, timeout: float, attempts: int) -> dict[str, str]:
                 return {
                     "audit_status": "broken",
                     "http_status": str(error.code),
-                    "final_url": url,
+                    "final_url": request_url,
                     "content_type": error.headers.get("content-type", "") if error.headers else "",
                     "source_title": "",
                     "source_description": "",
@@ -204,12 +379,13 @@ def fetch_url(url: str, timeout: float, attempts: int) -> dict[str, str]:
                     continue
 
         if attempt < attempts:
-            time.sleep(min(1.5, 0.25 * attempt))
+            delay = 1.5 * attempt if parsed_url.netloc.lower() == "code.claude.com" else 0.25 * attempt
+            time.sleep(min(4.0, delay))
 
     return {
         "audit_status": "unreachable",
         "http_status": "",
-        "final_url": url,
+        "final_url": request_url,
         "content_type": "",
         "source_title": "",
         "source_description": "",
@@ -230,12 +406,22 @@ def audit_row(row: dict[str, str], retrieved_at: str, timeout: float, attempts:
         "content_type": "",
         "source_title": "",
         "source_description": "",
+        "authors": "",
+        "publication_date": "",
+        "publication_year": "",
+        "publication_venue": "",
+        "publisher": "",
+        "doi": "",
+        "publication_note": "",
+        "primary_category": "",
+        "metadata_source": "",
         "github_repo": github_repo_from_url(row["url"]),
         "github_stars": "",
         "github_forks": "",
         "github_open_issues": "",
         "github_description": "",
         "github_license": "",
+        "github_created_at": "",
         "github_updated_at": "",
         "arxiv_id": arxiv_id_from_url(row["url"]),
         "error": "",
@@ -251,6 +437,9 @@ def audit_row(row: dict[str, str], retrieved_at: str, timeout: float, attempts:
                     "audit_status": "local_ok",
                     "final_url": f"{REPO_BLOB_URL}/{local_target}" + (f"#{fragment}" if fragment else ""),
                     "source_title": row["title"],
+                    "publication_year": "2026",
+                    "publisher": "Awesome Loop Engineering",
+                    "metadata_source": "repository",
                 }
             )
         else:
@@ -258,7 +447,15 @@ def audit_row(row: dict[str, str], retrieved_at: str, timeout: float, attempts:
         return base
 
     if row["url_kind"] == "local_anchor":
-        base.update({"audit_status": "local_anchor", "final_url": row["url"]})
+        base.update(
+            {
+                "audit_status": "local_anchor",
+                "final_url": row["url"],
+                "publication_year": "2026",
+                "publisher": "Awesome Loop Engineering",
+                "metadata_source": "repository",
+            }
+        )
         return base
 
     base.update(fetch_url(row["url"], timeout=timeout, attempts=attempts))
@@ -297,6 +494,7 @@ def github_stats_from_payload(data: dict[str, object]) -> dict[str, str]:
         "github_open_issues": str(data.get("open_issues_count", "")),
         "github_description": clean(str(description)),
         "github_license": clean(str(license_data.get("spdx_id", ""))),
+        "github_created_at": clean(str(data.get("created_at", ""))),
         "github_updated_at": clean(str(data.get("updated_at", ""))),
     }
 
@@ -330,6 +528,116 @@ def enrich_github(rows: list[dict[str, str]], timeout: float, use_gh_cli: bool)
         row.update(stats.get(row["github_repo"], {}))
 
 
+def fetch_arxiv_batch(arxiv_ids: list[str], timeout: float, attempts: int) -> dict[str, dict[str, str]]:
+    query = urlencode({"id_list": ",".join(arxiv_ids), "max_results": str(len(arxiv_ids))})
+    url = f"https://export.arxiv.org/api/query?{query}"
+    context = ssl._create_unverified_context()
+    request = urllib.request.Request(
+        url,
+        headers={"User-Agent": "awesome-loop-engineering-publication-audit"},
+    )
+
+    for attempt in range(1, attempts + 1):
+        try:
+            with urllib.request.urlopen(request, timeout=timeout, context=context) as response:
+                root = ET.fromstring(response.read())
+            break
+        except Exception:  # noqa: BLE001 - fallback metadata remains explicit below.
+            if attempt == attempts:
+                return {}
+            time.sleep(min(3.0, attempt))
+
+    records: dict[str, dict[str, str]] = {}
+    for entry in root.findall(f"{ATOM_NS}entry"):
+        entry_url = clean(entry.findtext(f"{ATOM_NS}id") or "")
+        match = ARXIV_RE.search(entry_url)
+        if not match:
+            continue
+        arxiv_id = match.group("id")
+        authors = [
+            clean(author.findtext(f"{ATOM_NS}name") or "")
+            for author in entry.findall(f"{ATOM_NS}author")
+        ]
+        primary = entry.find(f"{ARXIV_NS}primary_category")
+        published = normalize_date(entry.findtext(f"{ATOM_NS}published") or "")
+        journal_reference = clean(entry.findtext(f"{ARXIV_NS}journal_ref") or "")
+        records[arxiv_id] = {
+            "authors": "; ".join(author for author in authors if author),
+            "publication_date": published,
+            "publication_year": year_from_value(published),
+            "publication_venue": journal_reference or "arXiv",
+            "publisher": "arXiv",
+            "doi": normalize_doi(entry.findtext(f"{ARXIV_NS}doi") or ""),
+            "publication_note": clean(entry.findtext(f"{ARXIV_NS}comment") or ""),
+            "primary_category": clean(primary.get("term", "")) if primary is not None else "",
+            "metadata_source": "arxiv-api",
+        }
+    return records
+
+
+def arxiv_year(arxiv_id: str) -> str:
+    try:
+        return str(2000 + int(arxiv_id[:2]))
+    except (TypeError, ValueError):
+        return ""
+
+
+def enrich_arxiv(rows: list[dict[str, str]], timeout: float, attempts: int) -> None:
+    arxiv_ids = sorted({row["arxiv_id"] for row in rows if row["arxiv_id"]})
+    records: dict[str, dict[str, str]] = {}
+    batch_size = 75
+    for start in range(0, len(arxiv_ids), batch_size):
+        if start:
+            time.sleep(3.0)
+        records.update(fetch_arxiv_batch(arxiv_ids[start : start + batch_size], timeout, attempts))
+
+    for row in rows:
+        arxiv_id = row["arxiv_id"]
+        if not arxiv_id:
+            continue
+        metadata = records.get(arxiv_id)
+        if metadata:
+            row.update({key: value for key, value in metadata.items() if value})
+        else:
+            row["publisher"] = "arXiv"
+            row["publication_year"] = row["publication_year"] or arxiv_year(arxiv_id)
+            row["metadata_source"] = row["metadata_source"] or "arxiv-id"
+
+
+def year_from_url(url: str) -> str:
+    parsed = urlparse(url)
+    match = re.search(r"/(?:manuscript/)?(?P<year>20\d{2})(?:[/_-]|\d{2}\.)", parsed.path)
+    if not match:
+        return ""
+    year = int(match.group("year"))
+    return str(year) if year <= datetime.now(timezone.utc).year + 1 else ""
+
+
+def finalize_publication_metadata(rows: list[dict[str, str]]) -> None:
+    for row in rows:
+        override = PUBLICATION_OVERRIDES.get(row["url"], {})
+        row.update({key: value for key, value in override.items() if value})
+
+        if row["github_repo"]:
+            row["publisher"] = "GitHub"
+            row["publication_venue"] = row["publication_venue"] or row["github_repo"]
+            if not row["publication_date"] and row["github_created_at"]:
+                row["publication_date"] = normalize_date(row["github_created_at"])
+                row["metadata_source"] = "github-api"
+
+        if not row["publisher"]:
+            row["publisher"] = publisher_for_domain(row["domain"]) or "Awesome Loop Engineering"
+        if not row["publication_year"]:
+            row["publication_year"] = year_from_value(row["publication_date"])
+        if not row["publication_year"]:
+            row["publication_year"] = year_from_url(row["url"])
+            if row["publication_year"] and not row["metadata_source"]:
+                row["metadata_source"] = "url-date"
+        if not row["metadata_source"]:
+            row["metadata_source"] = "domain-fallback"
+        row["doi"] = normalize_doi(row["doi"])
+
+
 def write_audit(rows: list[dict[str, str]], out_path: Path = AUDIT_CSV) -> None:
     out_path.parent.mkdir(parents=True, exist_ok=True)
     with out_path.open("w", encoding="utf-8", newline="") as handle:
@@ -355,6 +663,8 @@ def main() -> int:
 
     audited.sort(key=lambda row: row["row_id"])
     enrich_github(audited, timeout=args.timeout, use_gh_cli=args.github_cli)
+    enrich_arxiv(audited, timeout=max(args.timeout, 20.0), attempts=args.attempts)
+    finalize_publication_metadata(audited)
     write_audit(audited)
 
     broken = [row for row in audited if row["audit_status"] in {"broken", "unreachable", "local_missing"}]

scripts/check_publication_metadata.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Validate bibliographic metadata in the generated resource dataset."""
+
+from __future__ import annotations
+
+import csv
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+RESOURCES = ROOT / "data" / "resources.csv"
+YEAR_RE = re.compile(r"^(19|20)\d{2}$")
+REQUIRED_COLUMNS = {
+    "authors",
+    "publication_date",
+    "publication_year",
+    "publication_venue",
+    "publisher",
+    "doi",
+    "publication_note",
+    "primary_category",
+    "metadata_source",
+}
+
+
+def main() -> int:
+    with RESOURCES.open(encoding="utf-8", newline="") as handle:
+        reader = csv.DictReader(handle)
+        missing = REQUIRED_COLUMNS - set(reader.fieldnames or [])
+        if missing:
+            print(f"Missing publication columns: {', '.join(sorted(missing))}", file=sys.stderr)
+            return 1
+        rows = list(reader)
+
+    failures: list[str] = []
+    maximum_year = datetime.now(timezone.utc).year + 1
+    for row in rows:
+        row_id = row["row_id"]
+        year = row["publication_year"]
+        date = row["publication_date"]
+
+        if not row["publisher"]:
+            failures.append(f"{row_id}: publisher/source platform is missing")
+        if not row["metadata_source"]:
+            failures.append(f"{row_id}: metadata provenance is missing")
+        if year:
+            if not YEAR_RE.fullmatch(year) or not 1900 <= int(year) <= maximum_year:
+                failures.append(f"{row_id}: invalid publication year {year!r}")
+            if date and not date.startswith(year):
+                failures.append(f"{row_id}: publication date {date!r} disagrees with year {year!r}")
+        if row["resource_type"] == "Paper":
+            if not row["authors"]:
+                failures.append(f"{row_id}: paper authors are missing")
+            if not year:
+                failures.append(f"{row_id}: paper publication year is missing")
+        if row["arxiv_id"]:
+            if row["publisher"] != "arXiv":
+                failures.append(f"{row_id}: arXiv row has publisher {row['publisher']!r}")
+            if not row["authors"]:
+                failures.append(f"{row_id}: arXiv authors are missing")
+            if not date:
+                failures.append(f"{row_id}: arXiv publication date is missing")
+            if row["metadata_source"] != "arxiv-api":
+                failures.append(f"{row_id}: arXiv metadata is not API-backed")
+        doi = row["doi"].lower()
+        if doi.startswith(("http://", "https://", "doi:")):
+            failures.append(f"{row_id}: DOI is not normalized")
+
+    if failures:
+        print("Publication metadata check failed:", file=sys.stderr)
+        for failure in failures[:50]:
+            print(f"- {failure}", file=sys.stderr)
+        if len(failures) > 50:
+            print(f"- ... and {len(failures) - 50} more", file=sys.stderr)
+        return 1
+
+    print(f"Validated publication metadata for {len(rows)} resources.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/export_resource_dataset.py

@@ -71,10 +71,20 @@ FIELDS = [
     "canonical_url",
     "source_title",
     "source_description",
+    "authors",
+    "publication_date",
+    "publication_year",
+    "publication_venue",
+    "publisher",
+    "doi",
+    "publication_note",
+    "primary_category",
+    "metadata_source",
     "github_repo",
     "github_stars",
     "github_forks",
     "github_license",
+    "github_created_at",
     "github_updated_at",
     "arxiv_id",
     "audited_at",
@@ -86,6 +96,10 @@ SITE_FIELDS = [
     "url",
     "canonical_url",
     "annotation",
+    "key_contribution",
+    "novelty",
+    "impact",
+    "signal",
     "resource_type",
     "collection",
     "user_goal",
@@ -96,7 +110,18 @@ SITE_FIELDS = [
     "evidence_class",
     "signal_strength",
     "source_status",
+    "authors",
+    "publication_date",
+    "publication_year",
+    "publication_venue",
+    "publisher",
+    "doi",
+    "publication_note",
+    "primary_category",
+    "metadata_source",
+    "github_repo",
     "github_stars",
+    "arxiv_id",
     "date_added",
 ]
 
@@ -479,10 +504,20 @@ def iter_rows(readme_path: Path = README) -> list[dict[str, str]]:
                 "canonical_url": audit.get("final_url", "") or url,
                 "source_title": audit.get("source_title", ""),
                 "source_description": audit.get("source_description", ""),
+                "authors": audit.get("authors", ""),
+                "publication_date": audit.get("publication_date", ""),
+                "publication_year": audit.get("publication_year", ""),
+                "publication_venue": audit.get("publication_venue", ""),
+                "publisher": audit.get("publisher", "") or domain or "Awesome Loop Engineering",
+                "doi": audit.get("doi", ""),
+                "publication_note": audit.get("publication_note", ""),
+                "primary_category": audit.get("primary_category", ""),
+                "metadata_source": audit.get("metadata_source", "not-audited"),
                 "github_repo": audit.get("github_repo", ""),
                 "github_stars": audit.get("github_stars", ""),
                 "github_forks": audit.get("github_forks", ""),
                 "github_license": audit.get("github_license", ""),
+                "github_created_at": audit.get("github_created_at", ""),
                 "github_updated_at": audit.get("github_updated_at", ""),
                 "arxiv_id": audit.get("arxiv_id", ""),
                 "audited_at": audit.get("retrieved_at", ""),

scripts/verify_urls.py

@@ -16,9 +16,11 @@ import time
 import urllib.error
 import urllib.request
 from pathlib import Path
+from urllib.parse import urlparse
 
 
 URL_RE = re.compile(r'https?://[^\s)\]}>"]+')
+CLAUDE_DOC_HOSTS = {"code.claude.com", "docs.anthropic.com"}
 
 
 class RedirectHandler(urllib.request.HTTPRedirectHandler):
@@ -56,6 +58,7 @@ def check_url(url: str, timeout: float, attempts: int) -> tuple[bool, str]:
         RedirectHandler(),
     )
     last_error = "unknown"
+    source_host = urlparse(url).netloc.lower()
 
     for attempt in range(1, attempts + 1):
         for method in ("HEAD", "GET"):
@@ -66,8 +69,14 @@ def check_url(url: str, timeout: float, attempts: int) -> tuple[bool, str]:
             )
             try:
                 with opener.open(request, timeout=timeout) as response:
+                    final_host = urlparse(response.geturl()).netloc.lower()
+                    if source_host == "code.claude.com" and final_host not in CLAUDE_DOC_HOSTS:
+                        return True, f"{response.status} restricted redirect"
                     return response.status < 400, f"{response.status} {method}"
             except urllib.error.HTTPError as error:
+                final_host = urlparse(error.geturl()).netloc.lower()
+                if source_host == "code.claude.com" and final_host not in CLAUDE_DOC_HOSTS:
+                    return True, f"{error.code} restricted redirect"
                 if error.code in {401, 403, 405, 406, 418, 429, 999}:
                     return True, f"{error.code} restricted"
                 if method == "HEAD":

templates/resource-entry.md

@@ -15,6 +15,10 @@ Use this when adding one resource to `README.md`.
 - **Evidence quality**: Tier A / B / C / D
 - **Why it belongs**:
 - **Primary or secondary source**:
+- **Authors / organization**:
+- **Publication year**:
+- **Venue or source platform**:
+- **DOI or arXiv ID**:
 - **Any caveat**:
 
 ## Quality Bar